form-macrorugo-compound.ts

import { IObservable, MacroRugo, MacrorugoCompound, Nub, Props, Session } from "jalhyd";

import { FormulaireBase } from "./form-base";
import { FormResultFixedVar } from "../form-result-fixedvar";
import { FormComputeFixedVar } from "../form-compute-fixedvar";
import { FieldSet } from "../../fieldset";
import { FieldsetContainer } from "../../fieldset-container";
import { FormulaireNode } from "../../formulaire-node";
import { FieldsetTemplate } from "../../fieldset-template";
import { NgParameter } from "../../ngparam";

/**
 * Formulaire pour les passes à macrorugosités complexes
 */
export class FormulaireMacrorugoCompound extends FormulaireBase {

    /** id of select configuring apron type */
    private _apronTypeSelectId: string;

    constructor() {
        super();
        this._formResult = new FormResultFixedVar(this);

        // default properties
        this._props["inclinedApron"] = false;

        // remove obsolete observer set by super()
        this.removeObserver(this._formCompute);
        this._formCompute = new FormComputeFixedVar(this, (this._formResult as FormResultFixedVar));
    }

    public get mrcNub(): MacrorugoCompound {
        return this.currentNub as MacrorugoCompound;
    }

    private createMacroRugoNub(templ: FieldsetTemplate): Nub {
        const params = {};
        params["calcType"] = templ.calcTypeFromConfig;
        return this.createMacroRugo(new Props(params));
    }

    /**
     * ajoute un nub MacroRugo
     * @param mr nub à ajouter
     * @param after position après laquelle insérer le nub, à la fin sinon
     */
    private addMacroRugoNub(mr: MacroRugo, after?: number) {
        this.mrcNub.addChild(mr, after);
    }

    /**
     * Asks JaLHyd to create a MacroRugo nub as a child of the current Calculator Module
     * and return it; does not store it in the Session (for MacroRugo, not for Calculator Modules)
     * @param p properties for the new Nub
     */
    protected createMacroRugo(p: Props): MacroRugo {
        return Session.getInstance().createNub(p, this.mrcNub) as MacroRugo;
    }

    /**
     * Replaces the given MacroRugo sn in the current calculator module,
     * with a new one built with properties "params"
     * @param mr MacroRugo to replace
     * @param params properties to build the new Nub (calcType)
     */
    protected replaceNub(mr: MacroRugo, params: Props): Nub {
        const parent = this.mrcNub;
        const newStructure = this.createMacroRugo(params);
        parent.replaceChildInplace(mr, newStructure);
        return newStructure;
    }

    public createFieldset(parent: FormulaireNode, json: {}, data?: {}, nub?: Nub): FieldSet {
        if (json["calcType"] === "MacroRugo") {
            // indice après lequel insérer le nouveau FieldSet
            const after = data["after"];

            const res: FieldSet = new FieldSet(parent);
            let mrn: Nub;
            if (nub) { // use existing Nub (build interface based on model)
                mrn = nub;
            } else {
                mrn = this.createMacroRugoNub(data["template"]);
                this.addMacroRugoNub(mrn as MacroRugo, after);
            }
            res.setNub(mrn, false);

            if (after !== undefined) {
                parent.kids.splice(after + 1, 0, res);
            } else {
                parent.kids.push(res);
            }

            this.resetResults();

            return res;
        } else {
            return super.createFieldset(parent, json, data);
        }
    }

    protected parseOptions(json: {}) {
        super.parseOptions(json);
        this._apronTypeSelectId = this.getOption(json, "apronTypeSelectId");
    }

    public afterParseFieldset(fs: FieldSet) {
        // if Fieldset contains apron type selector
        if (this._apronTypeSelectId) {
            const sel = fs.getFormulaireNodeById(this._apronTypeSelectId);
            if (sel) {
                // on abonne le formulaire aux propriétés du FieldSet
                fs.properties.addObserver(this);
            }
        }
    }

    public moveFieldsetUp(fs: FieldSet) {
        if (fs.nub instanceof MacroRugo) {
            // déplacement du nub
            fs.nub.parent.moveChildUp(fs.nub);
            // déplacement du fieldset
            this.fieldsetContainer.moveFieldsetUp(fs);

            this.resetResults();
        } else {
            super.moveFieldsetUp(fs);
        }
    }

    public moveFieldsetDown(fs: FieldSet) {
        if (fs.nub instanceof MacroRugo) {
            // déplacement du nub
            fs.nub.parent.moveChildDown(fs.nub);
            // déplacement du fieldset
            this.fieldsetContainer.moveFieldsetDown(fs);

            this.resetResults();
        } else { super.moveFieldsetDown(fs); }
    }

    public removeFieldset(fs: FieldSet) {
        if (fs.nub instanceof MacroRugo) {
            // suppression du sous-nub dans le Nub parent
            this.mrcNub.deleteChild(fs.nub.findPositionInParent());
            // suppression du fieldset
            this.fieldsetContainer.removeFieldset(fs);

            this.resetResults();
        } else { super.removeFieldset(fs); }
    }

    protected completeParse(json: {}) {
        this.subscribeFieldsetContainer();
    }

    private get fieldsetContainer(): FieldsetContainer {
        const n = this.getFormulaireNodeById("macrorugo_container");
        if (n === undefined || !(n instanceof FieldsetContainer)) {
            throw new Error("l'élément 'macrorugo_container' n'est pas du type FieldsetContainer");
        }
        return n as FieldsetContainer;
    }

    /**
     * abonnement en tant qu'observateur du FieldsetContainer
     */
    private subscribeFieldsetContainer() {
        this.fieldsetContainer.addObserver(this);
    }

    /**
     * abonnement en tant qu'observateur des NgParameter des FieldSet contenus dans le FieldsetContainer
     */
    private subscribeMacrorugoInputFields(fs: FieldSet) {
        for (const n of fs.allFormElements) {
            if (n instanceof NgParameter) {
                n.addObserver(this);
            }
        }
    }

    // interface Observer

    public update(sender: IObservable, data: any) {

        super.update(sender, data);

        if (sender instanceof FieldsetContainer) {
            switch (data.action) {
                case "newFieldset":
                    this.reset();
                    this.subscribeMacrorugoInputFields(data["fieldset"]);
            }
        } else  if (sender instanceof FieldSet && data.action === "propertyChange") {
            switch (data.name) {
                case "inclinedApron":
                    // reflect changes in GUI
                    for (const fs of this.allFieldsets) {
                        // show / hide dependent fields (read from model)
                        fs.updateFields();
                    }
                    // show / hide children list (GUI only)
                    for (const elt of this.allFormElements) {
                        if (elt instanceof FieldsetContainer) {
                            elt.isDisplayed = (! data.value);
                        }
                    }
                    this.reset();
                    this.debugMRC();
                    break;
            }
        }
    }

    private debugMRC() {
        console.log(`MRC: ${this.mrcNub.children.length} children`);
        for (const c of this.mrcNub.children) {
            console.log(` - ${c.uid} : ZF1=${c.prms.ZF1.singleValue}, B=${c.prms.B.singleValue}`);
        }
    }
}