@legalplace/conditions-runner 1.1.0

package/src/DataPopulator.ts

@@ -0,0 +1,316 @@
+import { Types } from "@legalplace/referencesparser";
+import type InputsType from "@legalplace/types/dist/inputs";
+import ConditionsRunner from "./ConditionsRunner";
+import { ConditionData, ConditionDataMap } from "./types/conditions.d";
+
+class DataPopulator {
+  private references: Types.ReferencesType;
+
+  private ovc: InputsType;
+
+  private conditionsRunner: ConditionsRunner;
+
+  private id?: number;
+
+  private index?: number;
+
+  private dataMap: ConditionDataMap;
+
+  private data: ConditionData = {
+    o: {},
+    v: {},
+    c: {
+      o: {},
+      s: {},
+      v: {},
+    },
+  };
+
+  constructor(
+    conditionsRunner: ConditionsRunner,
+    references: Types.ReferencesType,
+    ovc: InputsType,
+    dataMap: ConditionDataMap,
+    id?: number,
+    index?: number
+  ) {
+    this.id = id;
+    this.ovc = ovc;
+    this.index = index;
+    this.dataMap = dataMap;
+    this.references = references;
+    this.conditionsRunner = conditionsRunner;
+
+    // Populating variables
+    this.populateVariables();
+
+    // Populating options
+    this.populateOptions();
+
+    // Populating conditions
+    this.populateConditions();
+  }
+
+  /**
+   * Returns resulting data object
+   */
+  public getData(): Readonly<ConditionData> {
+    return this.data;
+  }
+
+  private populateConditions(): void {
+    // Sections
+    for (let i = 0; i < this.dataMap.c.s.length; i += 1) {
+      const sectionId = this.dataMap.c.s[i];
+      const sectionCondition = this.sectionConditionValue(sectionId);
+      this.data.c.s[sectionId] = [sectionCondition !== false];
+    }
+
+    // Options
+    for (let i = 0; i < this.dataMap.c.o.length; i += 1) {
+      const optionId = this.dataMap.c.o[i];
+      const optionCondition = [...this.getOptionConditions(optionId)];
+      this.data.c.o[optionId] =
+        optionCondition === undefined ? [false] : optionCondition;
+    }
+
+    // Variables
+    for (let i = 0; i < this.dataMap.c.v.length; i += 1) {
+      const variableId = this.dataMap.c.v[i];
+      const variableCondition = [...this.getVariablesConditions(variableId)];
+      this.data.c.v[variableId] =
+        variableCondition === undefined ? [false] : variableCondition;
+    }
+  }
+
+  /**
+   * Returns a give option's conditions
+   * @param optionId Option's id
+   */
+  private getOptionConditions(optionId: number): Readonly<boolean[]> {
+    const conditions = this.optionConditionValue(optionId);
+    if (conditions === undefined) return [true];
+    if (this.id === undefined || this.index === undefined) {
+      return conditions;
+    }
+
+    // Getting variable parent option
+    const optionRootParent = this.getOptionRootParent(optionId);
+    const optionRootRelations =
+      this.references.relations.options[optionRootParent];
+    if (
+      optionRootRelations.children.options.includes(this.id) ||
+      optionRootRelations.dependants.includes(this.id) ||
+      this.id === optionRootParent
+    ) {
+      if (conditions !== undefined && conditions[this.index] === false)
+        return [false];
+      return [conditions[this.index]];
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Returns a give variables conditions
+   * @param variableId Variable's id
+   */
+  private getVariablesConditions(variableId: number): Readonly<boolean[]> {
+    const conditions = this.variableConditionValue(variableId);
+    if (conditions === undefined) return [true];
+    if (this.id === undefined || this.index === undefined) {
+      return conditions;
+    }
+
+    // Getting variable parent option
+    const variableRootParent = this.getVariableRootParent(variableId);
+    const variableRootRelations =
+      this.references.relations.options[variableRootParent];
+    if (
+      variableRootRelations.children.options.includes(this.id) ||
+      variableRootRelations.dependants.includes(this.id) ||
+      this.id === variableRootParent
+    ) {
+      return [conditions[this.index]];
+    }
+
+    return conditions;
+  }
+
+  /**
+   * Populates variables according to the current dataMap object
+   */
+  private populateVariables(): void {
+    for (let i = 0; i < this.dataMap.v.length; i += 1) {
+      const variableId = this.dataMap.v[i];
+      const variableReference = this.references.variables[variableId];
+      let values = this.getVariableValues(variableId);
+
+      const parseNumber = (v: string) => {
+        const result = parseFloat(v);
+        return Number.isNaN(result) ? "" : result;
+      };
+      // If variable is of type number
+      if (variableReference.type === "number") {
+        values = values.map((v) =>
+          typeof v === "number" ? v : parseNumber(v)
+        );
+      }
+
+      // Adding variables
+      this.data.v[variableId] = [...values];
+    }
+  }
+
+  /**
+   * Returns a give variables value
+   * @param variableId Variable's id
+   */
+  private getVariableValues(variableId: number): Readonly<(string | number)[]> {
+    const value = this.ovc.variables[variableId];
+    if (this.id === undefined || this.index === undefined) {
+      return value;
+    }
+
+    // Getting variable parent option
+    const variableRootParent = this.getVariableRootParent(variableId);
+    const variableRootRelations =
+      this.references.relations.options[variableRootParent];
+    if (
+      variableRootRelations.children.options.includes(this.id) ||
+      variableRootRelations.dependants.includes(this.id) ||
+      this.id === variableRootParent
+    ) {
+      return [value[this.index]];
+    }
+
+    return this.cleanArrayFromNullValues([...value]);
+  }
+
+  /**
+   * Return a given variable root option relations
+   * @param variableId Variable's id
+   */
+  private getVariableRootParent(variableId: number) {
+    const variableParents =
+      this.references.relations.variables[variableId].parents;
+    return variableParents[variableParents.length - 1];
+  }
+
+  /**
+   * Cleans values array from any null value by replacing it
+   * with an empty string
+   * @param arr Values array
+   */
+  private cleanArrayFromNullValues(
+    arr: (string | number | null)[]
+  ): (string | number)[] {
+    return arr.map((v) => (v === null ? "" : v));
+  }
+
+  /**
+   * Populates options data object accodring to current dataMap object
+   */
+  populateOptions() {
+    for (let i = 0; i < this.dataMap.o.length; i += 1) {
+      const optionId = this.dataMap.o[i];
+      const inputs = this.getOptionInputs(optionId);
+
+      // Adding option
+      this.data.o[optionId] = [...inputs];
+    }
+  }
+
+  /**
+   * Returns a give option's inputs
+   * @param optionId Option's id
+   */
+  private getOptionInputs(optionId: number): Readonly<boolean[]> {
+    const inputs = this.ovc.options[optionId];
+    if (this.id === undefined || this.index === undefined) {
+      return inputs;
+    }
+
+    // Getting variable parent option
+    const optionRootParent = this.getOptionRootParent(optionId);
+    const optionRootRelations =
+      this.references.relations.options[optionRootParent];
+    if (
+      optionRootRelations.children.options.includes(this.id) ||
+      optionRootRelations.dependants.includes(this.id) ||
+      this.id === optionRootParent
+    ) {
+      return [inputs[this.index]];
+    }
+
+    return inputs;
+  }
+
+  /**
+   * Returns option's root parent
+   * @param optionId Root parent
+   */
+  private getOptionRootParent(optionId: number) {
+    const optionParents = this.references.relations.options[optionId].parents;
+    return optionParents.length > 0
+      ? optionParents[optionParents.length - 1]
+      : optionId;
+  }
+
+  /**
+   * Calculates option's condition
+   */
+  private optionConditionValue(optionId: number) {
+    // Getting option conditions
+    const conditions = this.references.conditions.options[optionId];
+    if (conditions === undefined) return undefined;
+
+    // Getting option inputs length
+    const inputs = this.ovc.options[optionId];
+
+    return inputs.map((input, index) =>
+      this.conditionsRunner.executeCondition(
+        conditions,
+        optionId,
+        index,
+        "options"
+      )
+    );
+  }
+
+  /**
+   * Calculates variable's condition
+   */
+  private variableConditionValue(variableId: number) {
+    // Getting variable conditions
+    const conditions = this.references.conditions.variables[variableId];
+    if (conditions === undefined) return undefined;
+
+    // Getting variable inputs length
+    const inputs = this.ovc.variables[variableId];
+
+    const result = inputs.map((input, index) =>
+      this.conditionsRunner.executeCondition(
+        conditions,
+        variableId,
+        index,
+        "variables"
+      )
+    );
+
+    return result;
+  }
+
+  /**
+   * Calculates section's condition
+   */
+  private sectionConditionValue(sectionId: number) {
+    // Getting section conditions
+    const conditions = this.references.conditions.sections.main[sectionId];
+    if (conditions === undefined) return undefined;
+
+    return this.conditionsRunner.executeCondition(conditions, 0, 0, "sections");
+  }
+}
+
+export default DataPopulator;