@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/ConditionsRunner/DataPopulator.ts

@@ -0,0 +1,266 @@
+import {
+  selectVariableReference,
+  selectVariableParents,
+  selectOptionRelations,
+  selectOptionParents,
+} from '../../redux/selectors/references';
+import {
+  selectVariableInput,
+  selectOptionInput,
+} from '../../redux/selectors/inputs';
+import {
+  selectVariableConditionValue,
+  selectOptionConditionValue,
+  selectSectionConditionValue,
+} from '../../redux/selectors/conditions';
+
+class DataPopulator {
+  private id?: number;
+
+  private index?: number;
+
+  private dataMap: ConditionDataMap;
+
+  private data: ConditionData = {
+    o: {},
+    v: {},
+    c: {
+      o: {},
+      s: {},
+      v: {},
+    },
+  };
+
+  constructor(dataMap: ConditionDataMap, id?: number, index?: number) {
+    this.id = id;
+    this.index = index;
+    this.dataMap = dataMap;
+
+    // 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 = selectSectionConditionValue(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 = selectOptionConditionValue(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 = selectOptionRelations(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 = selectVariableConditionValue(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 = selectOptionRelations(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 = selectVariableReference(variableId);
+      let values = this.getVariableValues(variableId);
+
+      // If variable is of type number
+      if (variableReference.type === 'number') {
+        values = values
+          .map((v) => (typeof v === 'number' ? v : parseFloat(v)))
+          .map((v) => (Number.isNaN(v) ? '' : 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 = selectVariableInput(variableId);
+    if (this.id === undefined || this.index === undefined) {
+      return value;
+    }
+
+    // Getting variable parent option
+    const variableRootParent = this.getVariableRootParent(variableId);
+    const variableRootRelations = selectOptionRelations(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 = selectVariableParents(variableId);
+    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 = selectOptionInput(optionId);
+    if (this.id === undefined || this.index === undefined) {
+      return inputs;
+    }
+
+    // Getting variable parent option
+    const optionRootParent = this.getOptionRootParent(optionId);
+    const optionRootRelations = selectOptionRelations(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 = selectOptionParents(optionId);
+    return optionParents.length > 0
+      ? optionParents[optionParents.length - 1]
+      : optionId;
+  }
+}
+
+export interface ConditionDataMap {
+  o: number[];
+  v: number[];
+  c: {
+    o: number[];
+    s: number[];
+    v: number[];
+  };
+}
+
+export interface ConditionData {
+  o: Record<string, boolean[]>;
+  v: Record<string, (string | number)[]>;
+  c: {
+    o: Record<string, boolean[]>;
+    s: Record<string, boolean[]>;
+    v: Record<string, boolean[]>;
+  };
+}
+
+export default DataPopulator;

package/src/libs/ConditionsRunner.ts

@@ -0,0 +1,454 @@
+/* eslint-disable max-len */
+import { Dispatch } from 'redux';
+import LpLogic from '@legalplace/lplogic/dist/LpLogic';
+import { selectOptionInput } from '../redux/selectors/inputs';
+import {
+  selectOptionRelations,
+  selectVariableRelations,
+  selectVariableParents,
+  selectOptionParents,
+  selectOptionConditionsObject,
+  selectVariableConditionsObject,
+  selectSectionConditionsObject,
+  selectPrefillerConditionsObject,
+  selectOptionValidatorConditionsObject,
+  selectVariableValidatorConditionsObject,
+  selectDocumentConditionsObject,
+  selectOptionReference,
+  selectSectionRelations,
+} from '../redux/selectors/references';
+import {
+  updateOptionConditionsAction,
+  updateVariableConditionsAction,
+  updateSectionConditionsAction,
+  updatePrefillersConditionsAction,
+  updateOptionValidatorConditionsAction,
+  updateVariableValidatorConditionsAction,
+  updateDocumentConditionsAction,
+} from '../redux/actions/conditions';
+import {
+  selectOptionConditionValue,
+  selectVariableConditionValue,
+  selectSectionConditionValue,
+  selectPrefillerConditionValue,
+  selectOptionValidatorConditionValue,
+  selectVariableValidatorConditionValue,
+  selectDocumentConditionValue,
+} from '../redux/selectors/conditions';
+import { StateType, MAPPED_CONDITIONS } from '../types/State.type';
+import DataPopulator from './ConditionsRunner/DataPopulator';
+
+// eslint-disable-next-line max-len
+export type AllConditions =
+  | StateType.Conditions.Options
+  | StateType.Conditions.Variables
+  | StateType.Conditions.Validators
+  | StateType.Conditions.Prefillers
+  | StateType.Conditions.Sections
+  | any[];
+
+const conditionValueSelectorsEnum: Record<string, (...args: any[]) => any> = {
+  options: selectOptionConditionValue,
+  variables: selectVariableConditionValue,
+  documents: selectDocumentConditionValue,
+  prefillers: selectPrefillerConditionValue,
+  optionValidator: selectOptionValidatorConditionValue,
+  variableValidator: selectVariableValidatorConditionValue,
+};
+
+const conditionObjectSelectorsEnum: Record<string, (...args: any[]) => any> = {
+  options: selectOptionConditionsObject,
+  variables: selectVariableConditionsObject,
+  documents: selectDocumentConditionsObject,
+  prefillers: selectPrefillerConditionsObject,
+  optionValidator: selectOptionValidatorConditionsObject,
+  variableValidator: selectVariableValidatorConditionsObject,
+};
+
+const updateDispatchActionsEnum: Record<string, (...args: any[]) => any> = {
+  options: updateOptionConditionsAction,
+  variables: updateVariableConditionsAction,
+  documents: updateDocumentConditionsAction,
+  prefillers: updatePrefillersConditionsAction,
+  optionValidator: updateOptionValidatorConditionsAction,
+  variableValidator: updateVariableValidatorConditionsAction,
+};
+
+export class ConditionsRunner {
+  dispatch: Dispatch;
+
+  constructor(dispatch: Dispatch) {
+    this.dispatch = dispatch;
+  }
+
+  shouldConditionUpdate(
+    oldCondition: AllConditions,
+    newCondition: AllConditions
+  ) {
+    let update = false;
+    if (Array.isArray(oldCondition) && Array.isArray(newCondition)) {
+      oldCondition.forEach((value, index) => {
+        if (Array.isArray(value)) {
+          update =
+            update || this.shouldConditionUpdate(value, newCondition[index]);
+        } else {
+          update = update || value !== newCondition[index];
+        }
+      });
+    } else {
+      update = oldCondition !== newCondition;
+    }
+
+    return update;
+  }
+
+  isOptionRelatedToOption(optionA: number, optionB: number): boolean {
+    // Getting B relations
+    const OptionBParents = selectOptionParents(optionB);
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+    const OptionBRootRelations = OptionBRoot
+      ? selectOptionRelations(OptionBRoot)
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (
+        optionA === optionB ||
+        OptionBRootRelations.children.options.includes(optionA) ||
+        OptionBRootRelations.dependants.includes(optionA)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  isVariableRelatedToOption(variableId: number, optionId: number): boolean {
+    // Variable parent
+    const variableParentId = selectVariableParents(variableId)[0];
+
+    // Getting B relations
+    const optionParents = selectOptionParents(variableParentId);
+    const optionRoot =
+      optionParents.length > 0
+        ? optionParents[optionParents.length - 1]
+        : variableParentId;
+    const optionRootRelations = optionRoot
+      ? selectOptionRelations(optionRoot)
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (optionRootRelations) {
+      if (
+        optionRootRelations.children.options.includes(optionId) ||
+        optionRootRelations.dependants.includes(optionId)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  isVariableRelatedToVariable(variableA: number, variableB: number): boolean {
+    // Getting variables options
+    const optionA = selectVariableParents(variableA)[0];
+    const optionB = selectVariableParents(variableB)[0];
+
+    // Getting B relations
+    const OptionBParents = selectOptionParents(optionB);
+    const OptionBRoot = OptionBParents[OptionBParents.length - 1];
+    const OptionBRootRelations = OptionBRoot
+      ? selectOptionRelations(OptionBRoot)
+      : undefined;
+
+    // Checking if B option is related to the option that changed
+    if (OptionBRootRelations) {
+      if (
+        optionA === optionB ||
+        OptionBRootRelations.children.options.includes(optionA) ||
+        OptionBRootRelations.dependants.includes(optionA)
+      ) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Return's real option inputs, in case option is child of a repeated
+   * it returns the inputs of the repeatOption
+   * @param optionId Option ID
+   */
+  getInputsForOption(optionId: number) {
+    let inputId = optionId;
+    const optionReference = selectOptionReference(optionId);
+    const optionParents = selectOptionParents(optionId);
+    if (optionParents.length > 0) {
+      const parentReference = selectOptionReference(optionParents[0]);
+      if (
+        parentReference.meta.type === 'repeated' &&
+        parentReference.meta.repeatOption !== undefined
+      ) {
+        inputId = parentReference.meta.repeatOption;
+      }
+    } else if (
+      optionReference.meta.type === 'repeated' &&
+      optionReference.meta.repeatOption !== undefined
+    ) {
+      inputId = optionReference.meta.repeatOption;
+    }
+
+    return selectOptionInput(inputId).map(
+      (input, currentIndex) => currentIndex
+    );
+  }
+
+  /**
+   * Return's real vriables inputs, in case variable is child of a multiple
+   * it returns the inputs of the repeatOption
+   * @param variableId Variable ID
+   */
+  getInputsForVariable(variableId: number) {
+    const optionId = selectVariableParents(variableId)[0];
+    let inputId = optionId;
+    const optionParents = selectOptionParents(optionId);
+    if (optionParents.length > 0) {
+      const parentReference = selectOptionReference(optionParents[0]);
+      if (
+        parentReference.meta.type === 'repeated' &&
+        parentReference.meta.repeatOption !== undefined
+      ) {
+        inputId = parentReference.meta.repeatOption;
+      }
+    }
+
+    return selectOptionInput(inputId).map(
+      (input, currentIndex) => currentIndex
+    );
+  }
+
+  executeHooks(
+    type: 'variables' | 'options' | 'sections',
+    id: number,
+    index: number
+  ) {
+    let hooks:
+      | StateType.References.Relations.Options
+      | StateType.References.Relations.Variables
+      | StateType.References.Relations.Sections;
+    switch (type) {
+      case 'options':
+        hooks = selectOptionRelations(id);
+        break;
+      case 'variables':
+        hooks = selectVariableRelations(id);
+        break;
+      case 'sections':
+        hooks = selectSectionRelations(id);
+        break;
+      default:
+        throw new Error(`Unkown hook type ${type}`);
+    }
+
+    type SubTypeTypes =
+      | 'options'
+      | 'variables'
+      | 'sections'
+      | 'prefillers'
+      | 'optionValidator'
+      | 'variableValidator'
+      | 'documents';
+
+    const subTypesList: SubTypeTypes[] = [
+      'options',
+      'variables',
+      'sections',
+      'prefillers',
+      'optionValidator',
+      'variableValidator',
+      'documents',
+    ];
+
+    subTypesList.forEach((subType) => {
+      if (subType === 'sections') {
+        return this.executeSectionsHooks(hooks, index);
+      }
+      let currentHooks: any[];
+
+      // Validators hooks
+      if (subType === 'optionValidator' || subType === 'variableValidator') {
+        currentHooks =
+          hooks.validators[
+            subType === 'optionValidator' ? 'options' : 'variables'
+          ];
+      } else {
+        currentHooks = hooks[subType];
+      }
+
+      // Executing hooks conditions
+      currentHooks.forEach((currentId: number) => {
+        const execId = subType === 'documents' ? 0 : currentId;
+        const updateId = subType === 'documents' ? currentId : currentId;
+
+        // Update indexes
+        let execIndexes: number[] = [];
+
+        if (
+          ['options', 'optionValidator'].includes(subType) &&
+          typeof updateId === 'number'
+        ) {
+          if (
+            type === 'options' &&
+            this.isOptionRelatedToOption(updateId, id)
+          ) {
+            execIndexes = [index];
+          } else if (
+            type === 'variables' &&
+            this.isVariableRelatedToOption(id, updateId)
+          ) {
+            execIndexes = [index];
+          } else {
+            execIndexes = this.getInputsForOption(updateId);
+          }
+        } else if (
+          ['variables', 'prefillers', 'variableValidator'].includes(subType) &&
+          typeof updateId === 'number'
+        ) {
+          if (
+            type === 'options' &&
+            this.isVariableRelatedToOption(updateId, id)
+          ) {
+            execIndexes = [index];
+          } else if (
+            type === 'variables' &&
+            this.isVariableRelatedToVariable(id, updateId)
+          ) {
+            execIndexes = [index];
+          } else {
+            execIndexes = this.getInputsForVariable(updateId);
+          }
+        } else {
+          execIndexes = [0];
+        }
+
+        // When we're executing an update on an option or an optionValidator,
+        // we need to make sure it is related to the hook to execute the same index
+        for (let i = 0; i < execIndexes.length; i += 1) {
+          // Getting the condition object
+          const condition = conditionObjectSelectorsEnum[subType](currentId);
+          const newCondition = this.executeCondition(
+            condition,
+            execId,
+            execIndexes[i],
+            subType
+          );
+
+          // Current condition
+          const oldCondition = conditionValueSelectorsEnum[subType](
+            currentId,
+            execIndexes[i]
+          );
+
+          if (this.shouldConditionUpdate(oldCondition, newCondition)) {
+            this.dispatch(
+              updateDispatchActionsEnum[subType](
+                updateId,
+                execIndexes[i],
+                newCondition
+              )
+            );
+          }
+        }
+      });
+
+      return null;
+    });
+  }
+
+  executeSectionsHooks(hooks: any, index: number) {
+    // Executing hooks conditions
+    Object.keys(hooks.sections).forEach((currentDocument: string) => {
+      hooks.sections[currentDocument].forEach((currentId: string) => {
+        // Getting the condition object
+        const condition = selectSectionConditionsObject(
+          parseInt(currentId, 10),
+          currentDocument
+        );
+        const newCondition = this.executeCondition(
+          condition,
+          parseInt(currentId, 10),
+          index,
+          'sections'
+        );
+
+        // Current condition
+        const oldCondition: any = selectSectionConditionValue(
+          parseInt(currentId, 10),
+          currentDocument
+        );
+        if (this.shouldConditionUpdate(oldCondition, newCondition)) {
+          this.dispatch(
+            updateSectionConditionsAction(
+              parseInt(currentId, 10),
+              currentDocument,
+              newCondition
+            )
+          );
+        }
+      });
+    });
+  }
+
+  executeCondition(
+    condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[],
+    id: number,
+    index: number,
+    conditionType: string
+  ): any {
+    if (Array.isArray(condition))
+      return condition.map((_condition) =>
+        this.executeCondition(_condition, id, index, conditionType)
+      );
+
+    // Returning true of condition is empty
+    if (
+      !(
+        typeof condition === 'object' &&
+        typeof condition.conditions === 'object' &&
+        Object.keys(condition.conditions).length > 0
+      )
+    )
+      return true;
+
+    // Populating Data
+    let currentData;
+    if (conditionType === 'options' || conditionType === 'optionValidator') {
+      currentData = new DataPopulator(condition.dataMap, id, index).getData();
+    } else if (
+      conditionType === 'variables' ||
+      conditionType === 'prefillers' ||
+      conditionType === 'variableValidator'
+    ) {
+      const dataId = selectVariableParents(id)[0];
+      currentData = new DataPopulator(
+        condition.dataMap,
+        dataId,
+        index
+      ).getData();
+    } else if (
+      conditionType === 'sections' ||
+      conditionType === 'documents' ||
+      conditionType === 'raw'
+    ) {
+      currentData = new DataPopulator(condition.dataMap).getData();
+    }
+    return LpLogic(condition.conditions, currentData);
+  }
+
+  executeRawCondition(condition: MAPPED_CONDITIONS | MAPPED_CONDITIONS[]) {
+    return this.executeCondition(condition, 0, 0, 'raw');
+  }
+}