formulaire.service.ts

import { Injectable } from "@angular/core";
import { Response } from "@angular/http";
import { Observable as rxObservable } from "rxjs/Observable";
import "rxjs/add/operator/toPromise";

import { ParamService } from "../param/param.service";
import { HttpService } from "../../services/http/http.service";
import { InternationalisationService } from "../../services/internationalisation/internationalisation.service";
import { FormulaireDefinition, CalculatorType } from "../../formulaire/formulaire-definition";
import { FormulaireElement } from "../../formulaire/formulaire-element";
import { SelectField } from "../../formulaire/select-field";
import { CheckField } from "../../formulaire/check-field";
import { StringMap } from "../../stringmap";
import { EnumEx } from "../../util";
import { Observable } from "../observer";

@Injectable()
export class FormulaireService extends Observable {
    private _formulaires: FormulaireDefinition[];

    constructor(private paramService: ParamService,
        private httpService: HttpService,
        private intlService: InternationalisationService
    ) {
        super();
        this._formulaires = [];
    }

    public get formulaires(): FormulaireDefinition[] {
        return this._formulaires;
    }

    private loadLocalisation(calc: CalculatorType): Promise<any> {
        let f: string = this.getConfigPathPrefix(calc) + this.intlService.currentLanguage.tag + ".json"
        let resp: rxObservable<Response> = this.httpService.httpGetRequestResponse(undefined, undefined, undefined, f);

        let prom = resp.map(res => res.text()).toPromise();
        return prom.then((res) => {
            let j = JSON.parse(res);
            return j as StringMap;
        })
    }

    /**
     * met à jour la langue du formulaire
     * @param formId id unique du formulaire
     * @param localisation ensemble id-message traduit
     */
    private updateFormulaireLocalisation(formId: number, localisation: StringMap) {
        for (let loc_id in localisation) {
            let fe = this.getFormulaireElementById(formId, loc_id);
            if (fe != undefined)
                fe.updateLocalisation(localisation);
        }
    }

    /**
     * charge la localisation et met à jour la langue du formulaire
     */
    private loadUpdateFormulaireLocalisation(f: FormulaireDefinition): Promise<any> {
        return this.loadLocalisation(f.calculatorType)
            .then(localisation => {
                this.updateFormulaireLocalisation(f.uid, localisation);
            });
    }

    public updateLocalisation() {
        for (const c of EnumEx.getValues(CalculatorType)) {
            const prom: Promise<StringMap> = this.loadLocalisation(c);
            prom.then(loc => {
                for (const f of this._formulaires)
                    if (f.calculatorType == c)
                        this.updateFormulaireLocalisation(f.uid, loc);
            }
            );
        }
    }

    private loadConfig(form: FormulaireDefinition, ct: CalculatorType): Promise<Response> {
        let processData = function (s: string) {
            form.parseConfig(JSON.parse(s));
        }

        let f: string = this.getConfigPathPrefix(ct) + "config.json"
        return this.httpService.httpGetRequest(undefined, undefined, undefined, f, processData);
    }

    public createFormulaire(ct: CalculatorType): Promise<FormulaireDefinition> {
        if (ct == undefined)
            throw "FormulaireService.createFormulaire() : invalid undefined CalculatorType"

        let f = new FormulaireDefinition(ct, this.paramService, this.intlService);
        this._formulaires.push(f);
        let prom: Promise<Response> = this.loadConfig(f, ct);
        return prom.then(_ => {
            return f;
        }).then(f => {
            this.loadUpdateFormulaireLocalisation(f);
            return f;
        }).then(f => {
            f.applyDependencies();
            return f;
        }).then(f => {
            this.notifyObservers(
                {
                    "action": "create",
                    "form": f
                });
            return f;
        });
    }

    public getFormulaireFromId(uid: number): FormulaireDefinition {
        for (let f of this._formulaires)
            if (f.uid == uid)
                return f;

        throw "FormulaireService.getFormulaire() : unkown form id " + uid;
    }

    public getCheckField(formId: number, elemId: string): CheckField {
        for (let f of this._formulaires)
            if (f.uid == formId) {
                let s = f.getFormulaireElementById(elemId);
                if (s != undefined) {
                    if (!(s instanceof CheckField))
                        throw "Form element with id '" + elemId + "' is not a checkbox";
                    return <CheckField>s;
                }
            }
        return undefined;
    }

    public getSelectField(formId: number, elemId: string): SelectField {
        for (let f of this._formulaires)
            if (f.uid == formId) {
                let s = f.getFormulaireElementById(elemId);
                if (s != undefined) {
                    if (!(s instanceof SelectField))
                        throw "Form element with id '" + elemId + "' is not a select";
                    return <SelectField>s;
                }
            }
        return undefined;
    }

    private getFormulaireElementById(formId: number, elemId: string): FormulaireElement {
        for (let f of this._formulaires)
            if (f.uid == formId) {
                let s = f.getFormulaireElementById(elemId);
                if (s != undefined)
                    return s;
            }
        return undefined;
    }

    private getConfigPathPrefix(ct: CalculatorType): string {
        if (ct == undefined)
            throw "FormulaireService.getConfigPathPrefix() : invalid undefined CalculatorType"

        switch (ct) {
            case CalculatorType.ConduiteDistributrice:
                return "app/calculators/cond_distri/cond_distri.";

            case CalculatorType.LechaptCalmon:
                return "app/calculators/lechapt-calmon/lechapt-calmon.";

            case CalculatorType.SectionParametree:
                return "app/calculators/section-param/section-param.";

            case CalculatorType.RegimeUniforme:
                return "app/calculators/regime-uniforme/regime-uniforme.";

            case CalculatorType.CourbeRemous:
                return "app/calculators/remous/remous.";

            default:
                throw "FormulaireService.getConfigPathPrefix() : valeur de CalculatorType " + ct + " non implémentée"
        }
    }
}