Skip to content
Snippets Groups Projects
internationalisation.service.ts 14.4 KiB
Newer Older
import { Injectable } from '@angular/core';

import { ErrorMessage, ErrorCode } from "jalhyd";

import { HttpService } from "../http/http.service";
/*
  language tag : fr-FR
  primary subcode : fr
  optional subcode : FR
 */
export enum Language {
    FRENCH,

    ENGLISH,
}

@Injectable()
export class InternationalisationService {
    private _lang: Language;
    private _sLang: string;
    private _errorMessages: { [key: string]: string };

    public constructor(private httpService: HttpService) { }

    public get lang() {
        return this._lang;
    }

    // public set lang(l: Language) {
    //     this._lang = l;
    //     this._sLang = Language[l];
    // }

    public setLocale(tag: string) {
        let l: string = tag.substr(0, 2).toLowerCase();
        if (l === "en")
            this._lang = Language.ENGLISH;
        else if (l === "fr")
            this._lang = Language.FRENCH;
        else {
            let e = new ErrorMessage(ErrorCode.ERROR_LANG_UNSUPPORTED);
            throw e;
        }

        // this.loadErrorMessages();
        this.httpGetErrorMessages();
    }

    get languageCode() {
        switch (this._lang) {
            case Language.ENGLISH:
                return "en";

            case Language.FRENCH:
                return "fr";

            default:
                throw new ErrorMessage(ErrorCode.ERROR_LANG_UNSUPPORTED);
        }
    }

    // private loadErrorMessages() {
    //     let l;
    //     switch (this.lang) {
    //         case Language.FRENCH:
    //             l = "fr";
    //             break;

    //         default:
    //             l = "en";
    //     }

    //     let s: string = fs.readFileSync("src/error_messages." + l + ".json", "utf8");
    //     this._errorMessages = JSON.parse(s);
    // }


    private httpGetErrorMessages() {
        let is: InternationalisationService = this;
        let processData = function (s: string) {
            // fermeture nécessaire pour capturer la valeur de this (undefined sinon)
            is._errorMessages = JSON.parse(s);
        }

        let l;
        switch (this.lang) {
            case Language.FRENCH:
                l = "fr";
                break;

            default:
                l = "en";
        }

        let f: string = "error_messages." + l + ".json"
        this.httpService.httpGetRequest(undefined, undefined, undefined, "locale/" + f, processData);
    }

    private getErrorMessageFromCode(c: ErrorCode): string {
        let sCode: string = ErrorCode[c];
        return this._errorMessages[ErrorCode[c]];
    }

    private replaceAll(str: string, find: string, replace: string) {
        return str.replace(new RegExp(find, 'g'), replace);
    }

    public localizeErrorMessage(r: ErrorMessage): string {
        let sCode: string = ErrorCode[r.code];
        let m: string = this.getErrorMessageFromCode(r.code);

        for (let k in r.extraVar) {
            m = this.replaceAll(m, "%" + k + "%", r.extraVar[k]);
        }

        return m;
    }

    /*
    public localizeErrorMessage(r: ErrorMessage): string {
        let m: string;
        let sCode: string = ErrorCode[r.code];

        switch (this.lang) {
            case Language.ENGLISH:
                switch (r.code) {
                    case ErrorCode.ERROR_DICHO_INIT_DOMAIN:
                        m = "Dichotomy : target " + r.extraVar["targetSymbol"];
                        m += "=" + r.extraVar["targetValue"];
                        m += " does not exist for variable " + r.extraVar["variableSymbol"];
                        m += " valued in interval " + r.extraVar["variableInterval"];
                        break;

                    case ErrorCode.ERROR_DICHO_INITVALUE_HIGH:
                    case ErrorCode.ERROR_DICHO_INITVALUE_LOW:
                        m = "Dichotomy : initial value " + r.extraVar["variableSymbol"];
                        m += "=" + r.extraVar["variableInitValue"];
                        if (r.code == ErrorCode.ERROR_DICHO_INITVALUE_HIGH)
                            m += " is too high";
                        else if (r.code == ErrorCode.ERROR_DICHO_INITVALUE_LOW)
                            m += " is too low";

                        m += " (target is " + r.extraVar["targetSymbol"];
                        m += "=" + r.extraVar["targetValue"];
                        m += ", " + r.extraVar["targetSymbol"];
                        m += "(" + r.extraVar["variableSymbol"];
                        m += "=" + r.extraVar["variableInitValue"]
                        m += ")=" + r.extraVar["initTarget"] + ")";
                        break;


                    case ErrorCode.ERROR_DICHO_NULL_STEP:
                        m = "Dichotomy (initial interval search) : invalid null step";
                        break;

                    case ErrorCode.ERROR_DICHO_INVALID_STEP_GROWTH:
                        m = "Dichotomy (initial interval search) : invalid null step growth";
                        break;

                    case ErrorCode.ERROR_DICHO_FUNCTION_VARIATION:
                        m = "unable to determinate function direction of variation";
                        break;

                    case ErrorCode.ERROR_PARAMDOMAIN_INTERVAL_BOUNDS:
                        m = "invalid ";
                        m += String(r.extraVar["minValue"]);
                        m += "/";
                        m += String(r.extraVar["maxValue"]);
                        m += " min/max boundaries for 'interval' parameter definition domain";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_CALC_UNDEFINED:
                        m = "calculability of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter is undefined";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_UNDEFINED:
                        m = "value of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter is undefined";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_FIXED:
                        m = "value of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter cannot be changed";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_POS:
                        m = "value ";
                        m += String(r.extraVar["value"]);
                        m += " of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter is invalid ";
                        m += " (cannot be <=0)";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_POSNULL:
                        m = "value ";
                        m += String(r.extraVar["value"]);
                        m += " of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter is invalid ";
                        m += " (cannot be <0)";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_NULL:
                        m = "value of '";
                        m += r.extraVar["symbol"];
                        m += "' parameter cannot be 0";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_INTERVAL:
                        m = "parameter '";
                        m += r.extraVar["symbol"];
                        m += "' : value ";
                        m += r.extraVar["value"];
                        m += " is out of [";
                        m += r.extraVar["minValue"];
                        m += ", ";
                        m += r.extraVar["maxValue"];
                        m += "] interval";
                        break;

                    case ErrorCode.ERROR_PARAMDOMAIN_INVALID:
                        m = "parameter '";
                        m += r.extraVar["symbol"];
                        m += "' : non supported '";
                        m += r.extraVar["domain"];
                        m += "' definition domain";
                        break;

                    case ErrorCode.ERROR_INTERVAL_UNDEF:
                        m = "Interval : invalid 'undefined' value";
                        break;

                    case ErrorCode.ERROR_INTERVAL_OUTSIDE:
                        m = "Interval : value ";
                        m += r.extraVar["value"];
                        m += " is outside of ";
                        m += r.extraVar["interval"];
                        break;

                    default:
                        throw "unprocessed ResultCode value " + sCode + " for language " + this._sLang;
                }
                break;

            case Language.FRENCH:
                switch (r.code) {
                    case ErrorCode.ERROR_DICHO_INIT_DOMAIN:
                        m = "Dichotomie : la valeur cible " + r.extraVar["targetSymbol"];
                        m += "=" + r.extraVar["targetValue"];
                        m += " n'existe pas pour la variable " + r.extraVar["variableSymbol"] + " prise dans l'intervalle " + r.extraVar["variableInterval"];
                        break;

                    case ErrorCode.ERROR_DICHO_INITVALUE_HIGH:
                    case ErrorCode.ERROR_DICHO_INITVALUE_LOW:
                        m = "Dichotomie : la valeur initiale " + r.extraVar["variableSymbol"];
                        m += "=" + r.extraVar["variableInitValue"];
                        if (r.code == ErrorCode.ERROR_DICHO_INITVALUE_HIGH)
                            m += " est trop grande";
                        else if (r.code == ErrorCode.ERROR_DICHO_INITVALUE_LOW)
                            m += " est trop petite";

                        m += " (la valeur cible est " + r.extraVar["targetSymbol"];
                        m += "=" + r.extraVar["targetValue"];
                        m += ", " + r.extraVar["targetSymbol"];
                        m += "(" + r.extraVar["variableSymbol"];
                        m += "=" + r.extraVar["variableInitValue"]
                        m += ")=" + r.extraVar["initTarget"] + ")";
                        break;

                    case ErrorCode.ERROR_DICHO_NULL_STEP:
                        m = "Dichotomie : le pas pour la recherche de l'intervalle de départ ne devrait pas être nul";
                        break;

                    case ErrorCode.ERROR_DICHO_INVALID_STEP_GROWTH:
                        m = "Dichotomie : l'augmentation du pas pour la recherche de l'intervalle de départ est incorrecte (=0)";
                        break;

                    case ErrorCode.ERROR_DICHO_FUNCTION_VARIATION:
                        m = "Dichotomie : impossible de determiner le sens de  variation de la fonction";
                        break;

                    case ErrorCode.ERROR_PARAMDOMAIN_INTERVAL_BOUNDS:
                        m = "Les bornes (";
                        m += String(r.extraVar["minValue"]);
                        m += "/";
                        m += String(r.extraVar["maxValue"]);
                        m += ") de l'intervalle sont incorrectes";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_CALC_UNDEFINED:
                        m = "La calculabilité du paramètre ";
                        m += r.extraVar["symbol"];
                        m += " n'est pas définie";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_UNDEFINED:
                        m = "La valeur du paramètre ";
                        m += r.extraVar["symbol"];
                        m += " n'est pas définie";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_FIXED:
                        m = "La valeur du paramètre ";
                        m += r.extraVar["symbol"];
                        m += " ne peut pas être changée";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_POS:
                        m = "La valeur ";
                        m += String(r.extraVar["value"]);
                        m += " du paramètre '";
                        m += r.extraVar["symbol"];
                        m += "' est incorrecte (<=0)";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_POSNULL:
                        m = "La valeur ";
                        m += String(r.extraVar["value"]);
                        m += " du paramètre '";
                        m += r.extraVar["symbol"];
                        m += "' est incorrecte (<0)";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_NULL:
                        m = "La valeur du paramètre '";
                        m += r.extraVar["symbol"];
                        m += "' ne peut pas être nulle";
                        break;

                    case ErrorCode.ERROR_PARAMDEF_VALUE_INTERVAL:
                        m = "Paramètre '";
                        m += r.extraVar["symbol"];
                        m += "' : la valeur ";
                        m += r.extraVar["value"];
                        m += " est en dehors de l'intervalle [";
                        m += r.extraVar["minValue"];
                        m += ", ";
                        m += r.extraVar["maxValue"];
                        m += "]";
                        break;

                    case ErrorCode.ERROR_PARAMDOMAIN_INVALID:
                        m = "Paramètre '";
                        m += r.extraVar["symbol"];
                        m += "' : le domaine de définition '";
                        m += r.extraVar["domain"];
                        m += "' est incorrect";
                        break;

                    case ErrorCode.ERROR_INTERVAL_UNDEF:
                        m = "Interval : valeur 'undefined' incorrecte";
                        break;

                    case ErrorCode.ERROR_INTERVAL_OUTSIDE:
                        m = "Interval : la valeur ";
                        m += r.extraVar["value"];
                        m += " est hors de l'intervalle ";
                        m += r.extraVar["interval"];
                        break;

                    default:
                        throw "unprocessed ResultCode value " + sCode + " for language " + this._sLang;
                }
                break;

            default:
                throw "unprocessed Language value " + this._sLang;
        }

        return m;
    }
    */
}