param.service.ts

import { ParamDomain, ParamDefinition, ParamDomainValue, ParamCalculability, NubFactory, SessionNub, Props } from "jalhyd";

import { NgParameter } from "../../formulaire/ngparam";
import { FormulaireDefinition } from "../../formulaire/definition/form-definition";
import { Injectable } from "@angular/core";
import { ServiceFactory } from "../service-factory";
import { InternationalisationService } from "../internationalisation/internationalisation.service";
import { ApplicationSetupService } from "../app-setup/app-setup.service";
import { FormulaireNode } from "../../formulaire/formulaire-node";

@Injectable()
export class ParamService {
    private get _intlService(): InternationalisationService {
        return ServiceFactory.instance.internationalisationService;
    }

    private get _appSetupService(): ApplicationSetupService {
        return ServiceFactory.instance.applicationSetupService;
    }

    private createAccuracyParameter(): ParamDefinition {
        const d = new ParamDomain(ParamDomainValue.INTERVAL, 1e-10, 100);
        const p = new ParamDefinition('Pr', d, this._appSetupService.computePrecision);
        p.calculability = ParamCalculability.FREE;
        return p;
    }

    /**
     *
     * @param calcType crée un NgParameter n'appartenant pas à un ComputeNode
     * @param symbol symbole du paramètre à créer
     */
    public createParameter(symbol: string, parent: FormulaireNode): NgParameter {
        let p: NgParameter;
        if (symbol === "Pr") {
            const prmDef: ParamDefinition = this.createAccuracyParameter();
            p = new NgParameter(prmDef.clone(), parent);
            p.confId = "Pr";
        } else {
            const dom = new ParamDomain(ParamDomainValue.POS_NULL);
            p = new NgParameter(new ParamDefinition(symbol, dom), parent);
            p.confId = symbol;

            switch (symbol) {
                case "Hs":
                case "Hsc":
                case "B":
                case "P":
                case "R":
                case "Yc":
                case "Yn":
                case "Yf":
                case "Yt":
                case "Yco":
                case "J":
                    p.unit = "m";
                    break;

                case "S":
                    p.unit = "m2";
                    break;

                case "V":
                    p.unit = "m/s";
                    break;

                case "I-J":
                    p.unit = "m/m";
                    break;

                case "Fr":
                    p.unit = "";
                    break;

                case "Imp":
                    p.unit = "N";
                    break;

                case "Tau0":
                    p.unit = "Pa";
                    break;

                case "Pr":
                    break;

                default:
                    throw new Error(`ParamService.createParameter() : symbole ${symbol} non pris en charge`);
            }
            p.updateLocalisation(this._intlService.currentMap);
        }

        return p;
    }

    public createSessionNub(params: Props | {}): SessionNub {
        return NubFactory.getInstance().createSessionNub(params);
    }

    public findSessionNub(params: Props | {}): SessionNub {
        return NubFactory.getInstance().findSessionNub(params);
    }

    public replaceSessionNub(sn: SessionNub, params: Props): SessionNub {
        return NubFactory.getInstance().replaceSessionNub(sn, params);
    }

    public moveStructureNubUp(sn: SessionNub) {
        NubFactory.getInstance().moveStructureNubUp(sn);
    }

    public moveStructureNubDown(sn: SessionNub) {
        NubFactory.getInstance().moveStructureNubDown(sn);
    }

    public deleteSessionNub(sn: SessionNub) {
        NubFactory.getInstance().deleteSessionNub(sn);
    }
}