déplacement de l'internationalisation des messages d'erreur depuis JalHyd dans NgHyd

src/app/app.component.ts

 import { Component } from '@angular/core';
 
 import { ParamService } from './param-service/param.service';
+import { HttpService } from './http.service';
+import { InternationalisationService } from './internationalisation.service';
 
 @Component({
   selector: 'nghyd-app',
@@ -12,7 +14,7 @@ import { ParamService } from './param-service/param.service';
   <!--
   -->
   `,
-  providers: [ParamService]
+  providers: [ParamService, InternationalisationService, HttpService]
 })
 export class AppComponent {
   title = "Calculette hydro";

src/app/app.module.ts

 import { BrowserModule } from '@angular/platform-browser';
 import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
 import { NgModule } from '@angular/core';
+import { HttpModule } from '@angular/http';
 import { FormsModule } from '@angular/forms'; // <-- NgModel lives here
 import { MdInputModule } from '@angular/material';
 
@@ -12,7 +13,7 @@ import { ParamInputComponent } from './param-input/param-input.component';
     BrowserModule,
     BrowserAnimationsModule,
     FormsModule, // <-- import the FormsModule before binding with [(ngModel)]
-    MdInputModule
+    MdInputModule, HttpModule
   ],
   declarations: [
     AppComponent,

src/app/http.service.ts

+import { Injectable } from '@angular/core';
+import { Http, RequestOptions, RequestOptionsArgs, Headers } from '@angular/http';
+
+@Injectable()
+export class HttpService {
+    constructor(private http: Http) { }
+
+    private concat(s1: string, s2: string): string {
+        if (s1 == undefined)
+            return s2;
+
+        if (s2 == undefined)
+            return s1;
+
+        return s1 + s2;
+    }
+
+    public httpGetRequest(protocol: string, host: string, port: number, path: string, processDataCallback: (s: string) => void) {
+        let url: string;
+        if (protocol != undefined)
+            url = protocol + "://" + host;
+        else if (host != undefined)
+            url = host;
+
+        if (port != undefined)
+            url = this.concat(url, ":" + String(port));
+
+        let p = path === "/" ? "" : path;
+        url = this.concat(url, "/" + p);
+
+        //console.log(url);
+        let enc = encodeURI(url);
+
+        let opts = new RequestOptions();
+
+        this.http.get(enc, opts)
+            .map(res => res.text())
+            .subscribe(
+            data => processDataCallback(data),
+            //            err => this.logError(err),
+            //            () => console.log('Random Quote Complete')
+        );
+    }
+}

src/app/internationalisation.service.ts

+import { Injectable } from '@angular/core';
+
+import { ErrorMessage, ErrorCode } from "jalhyd";
+
+import { HttpService } from "./http.service";
+
+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(loc: string) {
+        let l: string = loc.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);
+            e.extraVar["locale"] = loc;
+            throw e;
+        }
+
+        // this.loadErrorMessages();
+        this.httpGetErrorMessages();
+    }
+
+    // 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;
+    }
+    */
+}

src/app/param-input/param-input.component.ts

@@ -3,9 +3,10 @@
 import { Component, Input, forwardRef, OnInit, DoCheck, ChangeDetectorRef } from '@angular/core';
 import { ControlValueAccessor, NG_VALUE_ACCESSOR, NG_VALIDATORS, FormControl } from '@angular/forms';
 
-import { ParamDefinition, NumericalString, Internationalisation, Language, ErrorMessage } from 'jalhyd';
+import { ParamDefinition, NumericalString, ErrorMessage } from 'jalhyd';
 
 import { ParamService } from '../param-service/param.service';
+import { InternationalisationService, Language } from '../internationalisation.service';
 
 @Component({
     selector: 'param-input[symbol]',
@@ -57,7 +58,7 @@ export class ParamInputComponent implements ControlValueAccessor, OnInit, DoChec
      */
     private _uiValue: NumericalString;
 
-    constructor(private paramService: ParamService, private changeDetector: ChangeDetectorRef) {
+    constructor(private paramService: ParamService, private changeDetector: ChangeDetectorRef, private intlService: InternationalisationService) {
         this._id = ParamInputComponent._idGen++;
         if (ParamInputComponent._startTime == undefined)
             ParamInputComponent._startTime = new Date().getTime();
@@ -94,8 +95,8 @@ export class ParamInputComponent implements ControlValueAccessor, OnInit, DoChec
         this._paramDef = this.paramService.getParameter(this._paramSymbol);
 
         let docLocale: string = document['locale'] as string;
-        Internationalisation.getInstance().setLocale(docLocale);
-        console.log("doc locale " + docLocale);
+        this.intlService.setLocale(docLocale);
+        //        console.log("doc locale " + docLocale);
     }
 
     // private getValue() {
@@ -150,13 +151,13 @@ export class ParamInputComponent implements ControlValueAccessor, OnInit, DoChec
             }
             catch (e) {
                 if (e instanceof ErrorMessage)
-                    this._message = Internationalisation.getInstance().localizeErrorMessage(e);
+                    this._message = this.intlService.localizeErrorMessage(e);
                 else
                     this._message = "invalid value";
             }
         }
         else {
-            switch (Internationalisation.getInstance().lang) {
+            switch (this.intlService.lang) {
                 case Language.FRENCH:
                     this._message = "Veuillez entrer une valeur numérique";
                     break;
@@ -205,7 +206,7 @@ export class ParamInputComponent implements ControlValueAccessor, OnInit, DoChec
     }
 
     private log(m: string) {
-        let t: number = new Date().getTime() - ParamInputComponent._startTime;
+        // let t: number = new Date().getTime() - ParamInputComponent._startTime;
         //   console.log("ParamInputComponent(" + this._id + ") " + t + " : " + m);
     }
 

src/index.html

@@ -17,8 +17,8 @@
   <script src="systemjs.config.js"></script>
   <script>
     // Get the locale id somehow
-    document.locale = 'fr-FR';
-    // document.locale = 'en';
+    // document.locale = 'fr-FR';
+    document.locale = 'en';
 
     // Map to the text plugin
     System.config({

src/locale/error_messages.en.json

+{
+    "ERROR_DICHO_INIT_DOMAIN": "Dichotomy : target %targetSymbol%=%targetValue% does not exist for variable %variableSymbol% valued in interval %variableInterval%",
+    "ERROR_DICHO_INITVALUE_LOW": "Dichotomy : initial value %variableSymbol%=%variableInitValue% is too low (target is %targetSymbol%=%targetValue%, %targetSymbol%(%variableSymbol%=%variableInitValue%)=%initTarget%)",
+    "ERROR_DICHO_INITVALUE_HIGH": "Dichotomy : initial value %variableSymbol%=%variableInitValue% is too high (target is %targetSymbol%=%targetValue%, %targetSymbol%(%variableSymbol%=%variableInitValue%)=%initTarget%)",
+    "ERROR_DICHO_NULL_STEP": "Dichotomy (initial interval search) : invalid null step",
+    "ERROR_DICHO_INVALID_STEP_GROWTH": "Dichotomy (initial interval search) : invalid null step growth",
+    "ERROR_DICHO_FUNCTION_VARIATION": "unable to determinate function direction of variation",
+    "ERROR_PARAMDOMAIN_INTERVAL_BOUNDS": "invalid %minValue%/%maxValue% min/max boundaries for 'interval' parameter definition domain",
+    "ERROR_PARAMDEF_CALC_UNDEFINED": "calculability of '%symbol%' parameter is undefined",
+    "ERROR_PARAMDEF_VALUE_UNDEFINED": "value of '%symbol%' parameter is undefined",
+    "ERROR_PARAMDEF_VALUE_FIXED": "value of '%symbol%' parameter cannot be changed",
+    "ERROR_PARAMDEF_VALUE_POS": "value %value% of '%symbol%' parameter is invalid (cannot be <=0)",
+    "ERROR_PARAMDEF_VALUE_POSNULL": "value %value% of '%symbol%' parameter is invalid (cannot be <0)",
+    "ERROR_PARAMDEF_VALUE_NULL": "value of '%symbol%' parameter cannot be 0",
+    "ERROR_PARAMDEF_VALUE_INTERVAL": "parameter '%symbol%' : value %value% is out of [%minValue%, %maxValue%] interval",
+    "ERROR_PARAMDOMAIN_INVALID": "parameter '%symbol%' : non supported '%domain%' definition domain",
+    "ERROR_INTERVAL_UNDEF": "Interval : invalid 'undefined' value",
+    "ERROR_INTERVAL_OUTSIDE": "Interval : value %value% is outside of %interval",
+    "ERROR_LANG_UNSUPPORTED": "internationalisation : unsupported '%locale%' locale"
+}
\ No newline at end of file

src/locale/error_messages.fr.json

+{
+    "ERROR_DICHO_INIT_DOMAIN": "Dichotomie : la valeur cible %targetSymbol%=%targetValue% n'existe pas pour la variable %variableSymbol% prise dans l'intervalle %variableInterval%",
+    "ERROR_DICHO_INITVALUE_LOW": "Dichotomie : la valeur initiale %variableSymbol%=%variableInitValue% est trop petite (la valeur cible est %targetSymbol%=%targetValue%, %targetSymbol%(%variableSymbol%=%variableInitValue%)=%initTarget%)",
+    "ERROR_DICHO_INITVALUE_HIGH": "Dichotomie : la valeur initiale %variableSymbol%=%variableInitValue% est trop grande (la valeur cible est %targetSymbol%=%targetValue%, %targetSymbol%(%variableSymbol%=%variableInitValue%)=%initTarget%)",
+    "ERROR_DICHO_NULL_STEP": "Dichotomie : le pas pour la recherche de l'intervalle de départ ne devrait pas être nul",
+    "ERROR_DICHO_INVALID_STEP_GROWTH": "Dichotomie : l'augmentation du pas pour la recherche de l'intervalle de départ est incorrecte (=0)",
+    "ERROR_DICHO_FUNCTION_VARIATION": "Dichotomie : impossible de determiner le sens de  variation de la fonction",
+    "ERROR_PARAMDOMAIN_INTERVAL_BOUNDS": "Les bornes (%minValue%/%maxValue%) de l'intervalle sont incorrectes",
+    "ERROR_PARAMDEF_CALC_UNDEFINED": "La calculabilité du paramètre %symbol% n'est pas définie",
+    "ERROR_PARAMDEF_VALUE_UNDEFINED": "La valeur du paramètre %symbol% n'est pas définie",
+    "ERROR_PARAMDEF_VALUE_FIXED": "La valeur du paramètre %symbol% ne peut pas être changée",
+    "ERROR_PARAMDEF_VALUE_POS": "La valeur %value% du paramètre '%symbol%' est incorrecte (<=0)",
+    "ERROR_PARAMDEF_VALUE_POSNULL": "La valeur %value% du paramètre '%symbol%' est incorrecte (<0)",
+    "ERROR_PARAMDEF_VALUE_NULL": "La valeur du paramètre '%symbol%' ne peut pas être nulle",
+    "ERROR_PARAMDEF_VALUE_INTERVAL": "Paramètre '%symbol%' : la valeur %value% est en dehors de l'intervalle [%minValue%, %maxValue%]",
+    "ERROR_PARAMDOMAIN_INVALID": "Paramètre '%symbol%' : le domaine de définition '%domain%' est incorrect",
+    "ERROR_INTERVAL_UNDEF": "Interval : valeur 'undefined' incorrecte",
+    "ERROR_INTERVAL_OUTSIDE": "Interval : la valeur %value% est hors de l'intervalle %interval",
+    "ERROR_LANG_UNSUPPORTED": "internationalisation : locale '%locale%' non prise en charge"
+}
\ No newline at end of file