#77 réorganisation des dépendances pour gérer le fait que certains éléments...

 #77 réorganisation des dépendances pour gérer le fait que certains éléments maîtres (dont dépend la vérification des conditions) peuvent ne pas exister au moment de l'analyse du fichier de config de la calculette
- classe Dependency : stockage de l'id de l'élément maître plutôt que l'élément lui même, stockage de l'élément esclave
- classe FormulaireElement : ajout de applyDependency() pour appliquer une dépendance dont la condition a été vérifiée, suppression de verifyDependency()

src/app/formulaire/check-field.ts

@@ -20,10 +20,6 @@ export class CheckField extends Field {
         this._value = val;
     }
 
-    protected verifyDependency(d: Dependency): boolean {
-        throw "CheckField.verifyDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
-    }
-
     public get isValid(): boolean {
         return true;
     }

src/app/formulaire/dependency/dependency.ts

@@ -7,24 +7,44 @@ import { DependencyCondition } from "./dependency-condition";
  * cad que son affichage, sa valeur, ... sont modifiés
  */
 export abstract class Dependency {
-    private _master: FormulaireElement;
+    private _slave: FormulaireElement;
+
+    private _masterId: string;
 
     private _masterCondition: DependencyCondition;
 
-    constructor(m: FormulaireElement, mc: DependencyCondition) {
-        this._master = m;
+    constructor(s: FormulaireElement, mid: string, mc: DependencyCondition) {
+        this._slave = s;
+        this._masterId = mid;
         this._masterCondition = mc;
     }
 
-    public get masterElement(): FormulaireElement {
-        return this._master;
+    private getMasterElement(id: string): FormulaireElement {
+        let parentNode = this._slave.parent;
+        while (parentNode != undefined) {
+            var res: FormulaireElement = parentNode.getFormulaireNodeById(id) as FormulaireElement;
+            if (res != undefined)
+                return res;
+            parentNode = parentNode.parent;
+        }
+        return undefined;
+    }
+
+    protected get masterElement(): FormulaireElement {
+        return this.getMasterElement(this._masterId);
     }
 
     public get masterCondition(): DependencyCondition {
         return this._masterCondition;
     }
 
+    public apply() {
+        const master: FormulaireElement = this.masterElement;
+        if (master && master.verifiesDependency(this))
+            this._slave.applyDependency(this);
+    }
+
     public toString(): string {
-        return "master=" + this._master.toString() + "\n  " + this._masterCondition.toString();
+        return "slave=" + this._slave.toString() + "\n  mid=" + this._masterId + "\n  " + this._masterCondition.toString();
     }
 }

src/app/formulaire/dependency/value-dependency.ts

@@ -8,8 +8,8 @@ import { ValueDependencyCondition } from "./value-dependency-condition";
 export class ValueDependency extends Dependency {
     public slaveValue: any;
 
-    constructor(m: FormulaireElement, masterValue: any) {
-        super(m, new ValueDependencyCondition(masterValue));
+    constructor(slave: FormulaireElement, masterId: string, masterValue: any) {
+        super(slave, masterId, new ValueDependencyCondition(masterValue));
     }
 
     public toString() {

src/app/formulaire/field.ts

-import { FormulaireNode } from "./formulaire-node";
 import { FormulaireElement } from "./formulaire-element";
 import { ValueDependency } from "./dependency/value-dependency";
+import { Dependency } from "./dependency/dependency";
+import { isNumber } from "util";
 
 export abstract class Field extends FormulaireElement {
     public abstract get isValid();
@@ -11,15 +12,10 @@ export abstract class Field extends FormulaireElement {
     private parse_value_dependencies(json: {}) {
         for (let di in json) {
             let d = json[di];
-            let masterField: FormulaireElement = this.parent.getFormulaireNodeById(d["refid"]) as FormulaireElement;
-            if (masterField != undefined) {
-                let masterValue = d["refvalue"];
-                let dep = new ValueDependency(masterField, masterValue);
-                dep.slaveValue = d["value"];
-                this._dependencies.push(dep);
-            }
-            else
-                throw new Error(`la dépendance de valeur de '${this.id}' fait référence à un élément inconnu '${d["refid"]}'`);
+            let masterValue = d["refvalue"];
+            let dep = new ValueDependency(this, d["refid"], masterValue);
+            dep.slaveValue = d["value"];
+            this._dependencies.push(dep);
         }
     }
 
@@ -30,4 +26,18 @@ export abstract class Field extends FormulaireElement {
         if (dep != undefined)
             this.parse_value_dependencies(dep);
     }
+
+    /**
+     * applique une dépendance dont la condition a été vérifiée
+     */
+    public applyDependency(d: Dependency) {
+        if (d instanceof ValueDependency) {
+            if (isNumber(d.slaveValue))
+                this.setValue(this, +d.slaveValue);
+            else
+                this.setValue(this, d.slaveValue);
+        }
+        else
+            super.applyDependency(d);
+    }
 }

src/app/formulaire/fieldset-container.ts

@@ -65,10 +65,6 @@ export class FieldsetContainer extends FormulaireElement {
                     this.addTemplate(d);
     }
 
-    protected verifyDependency(d: Dependency): boolean {
-        return true;
-    }
-
     public updateLocalisation(loc?: StringMap) {
         if (loc == undefined)
             loc = this._localisation;

src/app/formulaire/fieldset.ts

@@ -75,10 +75,6 @@ export class FieldSet extends FormulaireElement implements Observer {
         return undefined;
     }
 
-    protected verifyDependency(d: Dependency): boolean {
-        throw "FieldSet.verifyDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
-    }
-
     public get isValid(): boolean {
         let res: boolean = true;
         for (const f of this.kids) {

src/app/formulaire/formulaire-element.ts

@@ -47,10 +47,6 @@ export abstract class FormulaireElement extends FormulaireNode {
         return super.kids as FormulaireElement[];
     }
 
-    private isNumber(s: string): boolean {
-        return Number(s) != NaN;
-    }
-
     /**
      * analyse les dépendances d'existence
      * @param json configuration de la dépendance
@@ -58,35 +54,30 @@ export abstract class FormulaireElement extends FormulaireNode {
     private parse_existence_dependencies(json: {}) {
         for (let di in json) {
             let d = json[di];
-            let masterField: FormulaireElement = parentNode.getFormulaireNodeById(d["refid"]) as FormulaireElement;
-            if (masterField != undefined) {
-                let rv = d["refvalue"];
-                if (rv != undefined)
-                    var mc: DependencyCondition = new ValueDependencyCondition(rv);
-                else {
-                    let cond = d["cond"];
-                    if (cond != undefined) {
-                        switch (cond) {
-                            case "isvar":
-                                var mc = new DependencyCondition(DependencyConditionType.IsVariable);
-                                break;
-
-                            case "isdisp":
-                                var mc = new DependencyCondition(DependencyConditionType.IsDisplayed);
-                                break;
-
-                            default:
-                                throw "Formulaire.parse_existence_dependencies() : type de condition '" + cond + "' non pris en charge";
-                        }
+            let rv = d["refvalue"];
+            if (rv != undefined)
+                var mc: DependencyCondition = new ValueDependencyCondition(rv);
+            else {
+                let cond = d["cond"];
+                if (cond != undefined) {
+                    switch (cond) {
+                        case "isvar":
+                            var mc = new DependencyCondition(DependencyConditionType.IsVariable);
+                            break;
+
+                        case "isdisp":
+                            var mc = new DependencyCondition(DependencyConditionType.IsDisplayed);
+                            break;
+
+                        default:
+                            throw "Formulaire.parse_existence_dependencies() : type de condition '" + cond + "' non pris en charge";
                     }
-                    else
-                        throw "Formulaire.parse_existence_dependencies() : infos de dépendance manquantes/non prises en charge";
                 }
-                let dep = new ExistenceDependency(masterField, mc);
-                this._dependencies.push(dep);
+                else
+                    throw "Formulaire.parse_existence_dependencies() : infos de dépendance manquantes/non prises en charge";
             }
-            else
-                console.log(`WARNING : la dépendance d'existence de '${this.id}' fait référence à un élément inconnu '${d["refid"]}'`);
+            let dep = new ExistenceDependency(this, d["refid"], mc);
+            this._dependencies.push(dep);
         }
     }
 
@@ -101,23 +92,17 @@ export abstract class FormulaireElement extends FormulaireNode {
             this.parse_existence_dependencies(dep);
     }
 
-    protected abstract verifyDependency(d: Dependency): boolean;
-
     public verifiesDependency(d: Dependency): boolean {
         if (d.masterCondition.type == DependencyConditionType.IsDisplayed)
             return this._isDisplayed;
-
-        return this.verifyDependency(d);
     }
 
-    private getDependencyFromMasterValue(v: any): Dependency {
-        for (let d of this._dependencies)
-            if (d.masterCondition.type == DependencyConditionType.HasValue) {
-                let mv = (<ValueDependencyCondition>d.masterCondition).value;
-                if (mv === v)
-                    return d;
-            }
-        return undefined;
+    /**
+     * applique une dépendance dont la condition a été vérifiée
+     */
+    public applyDependency(d: Dependency) {
+        if (d instanceof ExistenceDependency)
+            this.isDisplayed = true;
     }
 
     private prepareExistenceDependencies() {
@@ -134,28 +119,7 @@ export abstract class FormulaireElement extends FormulaireNode {
         this.prepareExistenceDependencies();
 
         for (let d of this._dependencies) {
-            let master: FormulaireElement = d.masterElement;
-            if (d instanceof ExistenceDependency && !this._isDisplayed) {
-                let slave: FormulaireElement = this;
-                slave.isDisplayed = slave._isDisplayed || (master.isDisplayed && master.verifiesDependency(d)); // le problème c'est que master.isDisplayed n'est pas forcément correct à ce moment précis...
-            }
-            else if (d instanceof ValueDependency) {
-                let vd = <ValueDependency>d;
-                /*
-                let master: HTMLElement = this.getHtmlElementFromId(d.masterElement.id);
-                if (this.getHtmlElementValue(master) == vd.masterValue) {
-                    let slave: HTMLElement = this.getHtmlElementFromId(d.slaveElement.id);
-                    this.setHtmlElementValue(slave, vd.slaveValue);
-                }
-                */
-                if (master.verifiesDependency(d)) {
-                    let slave = parentForm.getFieldById(this.id);
-                    if (this.isNumber(vd.slaveValue))
-                        slave.setValue(this, +vd.slaveValue);
-                    else
-                        slave.setValue(this, vd.slaveValue);
-                }
-            }
+            d.apply();
         }
 
         for (const k of this.getKids())

src/app/formulaire/ngparam.ts

@@ -290,7 +290,10 @@ export class NgParameter extends InputField {
         this.isDefault = false; // malgré le fait qu'il soit initialisé dans la déclaration de la classe NgParam à false, quand on relit sa valeur, il vaut undefined (merci Microsoft)
     }
 
-    protected verifyDependency(d: Dependency): boolean {
+    public verifiesDependency(d: Dependency): boolean {
+        if (super.verifiesDependency(d))
+            return true;
+
         switch (d.masterCondition.type) {
             case DependencyConditionType.HasValue:
                 {
@@ -302,7 +305,7 @@ export class NgParameter extends InputField {
                 return this.radioState == ParamRadioConfig.VAR;
 
             default:
-                throw "NgParameter.verifyDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
+                throw "NgParameter.verifiesDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
         }
     }
 

src/app/formulaire/select-field.ts

@@ -60,14 +60,17 @@ export class SelectField extends Field {
         return this._selectedEntry.label;
     }
 
-    protected verifyDependency(d: Dependency): boolean {
+    public verifiesDependency(d: Dependency): boolean {
+        if (super.verifiesDependency(d))
+            return true;
+
         switch (d.masterCondition.type) {
             case DependencyConditionType.HasValue:
                 let mc: ValueDependencyCondition = <ValueDependencyCondition>d.masterCondition;
                 return this._selectedEntry.id === mc.value;
 
             default:
-                throw "SelectField.verifyDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
+                throw "SelectField.verifiesDependency() : type de condition '" + DependencyConditionType[d.masterCondition.type] + "' non pris en charge";
         }
     }
 

src/app/util.ts

@@ -5,3 +5,7 @@ export function logObject(obj: {}, m?: string) {
     else
         console.log(m + " " + JSON.stringify(obj));
 }
+
+export function isNumber(s: string): boolean {
+    return Number(s) != NaN;
+}