@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/middlewares/mandatoriesWatcherMiddleware.ts

@@ -0,0 +1,473 @@
+import { Dispatch, MiddlewareAPI } from 'redux';
+import {
+  UPDATE_OPTION_INPUT,
+  UPDATE_VARIABLE_INPUT,
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import {
+  selectVariableInputByIndex,
+  selectOptionInputByIndex,
+  selectOptionInput,
+} from '../selectors/inputs';
+import { ActionsType } from '../../types/Actions.type';
+import {
+  SET_MANDATORY_OPTION,
+  SET_MANDATORY_VARIABLE,
+} from '../constants/mandatories';
+import {
+  selectOptionRelations,
+  selectOptionReference,
+  selectSectionReference,
+  selectVariableRelations,
+  selectAllSectionsReferences,
+  selectRadioSiblings,
+} from '../selectors/references';
+import {
+  selectMandatoryOption,
+  selectMandatoryVariable,
+} from '../selectors/mandatories';
+import { StateType } from '../../types/State.type';
+import {
+  setMandatoryOptionAction,
+  setMandatorySectionAction,
+  setMandatoryVariableAction,
+} from '../actions/mandatories';
+import {
+  UPDATE_OPTION_CONDITION,
+  UPDATE_VARIABLE_CONDITION,
+  UPDATE_SECTION_CONDITION,
+} from '../constants/conditions';
+import {
+  selectOptionConditionValue,
+  selectVariableConditionValue,
+  selectIsOptionDisplayed,
+  selectIsVariableDisplayed,
+} from '../selectors/conditions';
+import { FETCH_MODEL_SUCCEEDED } from '../constants/app';
+
+export type WatcherActions =
+  | ActionsType.Inputs.updateOptionInput
+  | ActionsType.Inputs.updateVariableInput
+  | ActionsType.Inputs.addMultipleOccurency
+  | ActionsType.Inputs.deleteMultipleOccurency
+  | ActionsType.Mandatories.setMandatoryOption
+  | ActionsType.Mandatories.setMandatoryVariable;
+
+/**
+ * Validates section mandatory children
+ * @param mpi Middleware API
+ * @param sectionId Section's ID
+ */
+const validateSectionMandatory = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  sectionId: number
+) => {
+  // Parent section
+  const parentSection = selectSectionReference(sectionId);
+
+  // Getting all child options
+  let childOptions: number[] = [...parentSection.options];
+  let childVariables: number[] = [];
+  parentSection.options.forEach((childOptionId) => {
+    // we will take all childs of the selected radio
+    let childOptionSelectedId;
+    let otherOptions: number[] = [];
+    const childReferenceOption = selectOptionReference(childOptionId);
+    childReferenceOption.options.forEach((subChildOptionId) => {
+      const optionReference = selectOptionReference(subChildOptionId);
+      const { type: optionType } = optionReference.meta;
+      // searching for selected radio
+      if (['radio'].includes(optionType)) {
+        // Make sure it is a selected value.
+        if (selectOptionInput(subChildOptionId).every((v) => v === true))
+          childOptionSelectedId = subChildOptionId;
+      } else {
+        otherOptions = [...otherOptions, subChildOptionId];
+        childVariables = [
+          ...childVariables,
+          ...selectOptionRelations(childOptionId).children.variables,
+        ];
+      }
+    });
+    // if there is childOptionSelected
+    if (childOptionSelectedId) {
+      const childRelations = selectOptionRelations(childOptionSelectedId);
+      childOptions = [
+        ...childOptions,
+        childOptionSelectedId,
+        ...childRelations.children.options,
+        ...otherOptions,
+      ];
+      childVariables = [
+        ...childVariables,
+        ...childRelations.children.variables,
+      ];
+    } else {
+      // Code of Moncef: Initialization related to relations of childOptionId
+      const childRelations = selectOptionRelations(childOptionId);
+      childOptions = [...childOptions, ...childRelations.children.options];
+      childVariables = [
+        ...childVariables,
+        ...childRelations.children.variables,
+      ];
+    }
+  });
+
+  // Delete Duplication of variablesIds
+  childVariables = childVariables.filter((item, pos, self) => {
+    return self.indexOf(item) === pos;
+  });
+
+  // Filtring children with mandatory displayed children only
+  childOptions = childOptions.filter((childId) =>
+    Object.prototype.hasOwnProperty.call(
+      mpi.getState().mandatories.options,
+      childId
+    )
+  );
+  childVariables = childVariables.filter((childId) =>
+    Object.prototype.hasOwnProperty.call(
+      mpi.getState().mandatories.variables,
+      childId
+    )
+  );
+  // Getting child options values
+  const sectionOptionsValues = childOptions.reduce(
+    (previousValue, currentOptionId) => {
+      const currentOptionValue = selectMandatoryOption(currentOptionId)
+        .map((value, index) => {
+          const displayed = selectIsOptionDisplayed(currentOptionId, index);
+          let result = !displayed || (displayed && value);
+          // When its multiple case we need to take the value of sibling
+          if (result === false) {
+            const siblings = selectRadioSiblings(currentOptionId);
+            if (siblings && siblings.length) {
+              siblings.forEach((siblingOptionId) => {
+                if (result === false) {
+                  if (childOptions.includes(siblingOptionId)) {
+                    const displayedSibling = selectIsOptionDisplayed(
+                      currentOptionId,
+                      index
+                    );
+                    const selectedSibling =
+                      selectOptionInput(siblingOptionId)[index];
+
+                    result =
+                      !displayedSibling ||
+                      (displayedSibling &&
+                        selectMandatoryOption(siblingOptionId)[index] &&
+                        selectedSibling);
+                  } else if (selectOptionInput(siblingOptionId)[index]) {
+                    result = true;
+                  }
+                }
+              });
+            }
+          }
+          return result;
+        })
+        .every((v) => v === true);
+
+      return previousValue && currentOptionValue;
+    },
+    true
+  );
+
+  // Getting child variables values
+  const sectionVariablesValues = childVariables.reduce(
+    (previousValue, currentVariableId) => {
+      // Checking whether child option itself is
+      const currentVariableValue = selectMandatoryVariable(currentVariableId)
+        .map((value, index) => {
+          const displayed = selectIsVariableDisplayed(currentVariableId, index);
+          return !displayed || (displayed && value);
+        })
+        .every((v) => v === true);
+
+      return previousValue && currentVariableValue;
+    },
+    true
+  );
+
+  // Determining section value
+  const sectionValue = sectionOptionsValues && sectionVariablesValues;
+
+  // Setting new section's value if changed
+  if (mpi.getState().mandatories.sections[sectionId] !== sectionValue) {
+    mpi.dispatch(setMandatorySectionAction(sectionId, sectionValue));
+  }
+};
+
+/**
+ * Watching:
+ * ADD_MULTIPLE_OCCURENCY
+ * DELETE_MULTIPLE_OCCURENCY
+ * SET_MANDATORY_OPTION
+ * SET_MANDATORY_VARIABLE
+ * UPDATE_SECTION_CONDITION
+ * UPDATE_OPTION_CONDITION
+ * UPDATE_OPTION_INPUT
+
+ * actions
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchSectionMandatory = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action:
+    | ActionsType.Inputs.addMultipleOccurency
+    | ActionsType.Inputs.deleteMultipleOccurency
+    | ActionsType.Mandatories.setMandatoryOption
+    | ActionsType.Mandatories.setMandatoryVariable
+    | ActionsType.Conditions.updateSectionCondition
+    | ActionsType.Conditions.updateOptionCondition
+    | ActionsType.Inputs.updateOptionInput
+) => {
+  const { type, id } = action;
+
+  // Executing action
+  next(action);
+  let sectionId: number | undefined = id;
+  if (action.type !== UPDATE_SECTION_CONDITION) {
+    // Determine if it's a variable
+    const isVariable = [SET_MANDATORY_VARIABLE].includes(type);
+
+    // Getting root parent
+    const { parents } = isVariable
+      ? selectVariableRelations(id)
+      : selectOptionRelations(id);
+    const rootParentId = parents.length > 0 ? parents[parents.length - 1] : id;
+
+    // Getting section id
+    sectionId = Object.keys(selectAllSectionsReferences() || {})
+      .map((v) => parseInt(v, 10))
+      .find((currentSectionId) =>
+        selectSectionReference(currentSectionId).options.includes(rootParentId)
+      );
+
+    // If we can't find the parent section
+    // we have a huge problem, let's stop here
+    // if (sectionId === undefined)
+    //   throw new Error(
+    //     `Unable to find parent section for option ${id} (rootParent: ${rootParentId})`
+    //   );
+  }
+  if (sectionId !== undefined) validateSectionMandatory(mpi, sectionId);
+};
+
+/**
+ * Watching UPDATE_VARIABLE_INPUT and UPDATE_VARIABLE_CONDITION actions
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateVariableInputCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action:
+    | ActionsType.Inputs.updateVariableInput
+    | ActionsType.Conditions.updateVariableCondition,
+  ignoreNext?: boolean
+) => {
+  const { type, id, index, value } = action;
+
+  // Executing action, ignoring in case ignoreNext is true
+  // ignoreNext is set to true when we're checking option's
+  // decendants (Check watchUpdateOptionInputCondition)
+  if (ignoreNext !== true) next(action);
+
+  // Making sure variable is mandatory
+  if (mpi.getState().mandatories.variables[id] === undefined) return;
+
+  // Getting input value
+  const inputValue =
+    type === UPDATE_VARIABLE_INPUT
+      ? `${value}`.trim().length > 0
+      : `${selectVariableInputByIndex(id, index)}`.trim().length > 0;
+
+  // Getting condition value
+  const conditionValue =
+    action.type === UPDATE_VARIABLE_CONDITION
+      ? action.value
+      : selectVariableConditionValue(id, index) !== false;
+
+  // Mandatory value
+  const mandatoryValue = !conditionValue || (conditionValue && inputValue);
+
+  mpi.dispatch(setMandatoryVariableAction(id, index, mandatoryValue));
+};
+
+/**
+ * Watching UPDATE_OPTION_INPUT and UPDATE_OPTION_CONDITION actions
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateOptionInputCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action:
+    | ActionsType.Inputs.updateOptionInput
+    | ActionsType.Conditions.updateOptionCondition,
+  ignoreNext?: boolean
+) => {
+  const { type, id, index, value } = action;
+
+  // Executing next action
+  if (ignoreNext !== true) next(action);
+
+  // Getting option refence
+  const optionReference = selectOptionReference(id);
+  const { type: optionType } = optionReference.meta;
+
+  // Excluding all options except radio & checkbox
+  if (['radio', 'checkbox'].includes(optionType)) {
+    // Getting input value
+    const inputValue =
+      type === UPDATE_OPTION_INPUT
+        ? value
+        : selectOptionInputByIndex(id, index) === true;
+
+    // Getting condition value
+    const conditionValue =
+      type === UPDATE_OPTION_CONDITION
+        ? value
+        : selectOptionConditionValue(id, index) !== false;
+
+    // Mandatory value
+    const mandatoryValue = !conditionValue || (conditionValue && inputValue);
+
+    if (optionType === 'radio') {
+      // Getting option's parents
+      const { parents } = selectOptionRelations(id);
+
+      // radio get ParentId else id
+      const [parentId] = parents;
+
+      // Getting siblings reduced value
+      const parentOption = selectOptionReference(parentId);
+      const siblingsMandatoryValues = parentOption?.options
+        ?.filter(
+          (optionId) =>
+            optionId !== id &&
+            selectOptionReference(optionId).meta.type === 'radio'
+        )
+        .map((optionId) => {
+          // Getting input value
+          const siblingInputValue =
+            selectOptionInputByIndex(optionId, index) === true;
+
+          // Getting condition value
+          const siblingConditionValue =
+            selectOptionConditionValue(id, index) !== false;
+
+          return (
+            !siblingConditionValue ||
+            (siblingConditionValue && siblingInputValue)
+          );
+        });
+
+      const hasTruthfullSibling = siblingsMandatoryValues?.includes(true);
+
+      if (mpi.getState().mandatories.options[parentId] === undefined) return;
+      mpi.dispatch(
+        setMandatoryOptionAction(
+          parentId,
+          index,
+          mandatoryValue || hasTruthfullSibling
+        )
+      );
+    } else {
+      // Checkbox Case
+      if (mpi.getState().mandatories.options[id] === undefined) return;
+      mpi.dispatch(setMandatoryOptionAction(id, index, mandatoryValue));
+    }
+  }
+  // Checking Mandatories for direct children
+  const { options, variables } = selectOptionReference(id);
+  if (options && options.length) {
+    options.forEach((optionId) => {
+      watchUpdateOptionInputCondition(
+        mpi,
+        next,
+        {
+          type: UPDATE_OPTION_CONDITION,
+          id: optionId,
+          index,
+          value: selectOptionConditionValue(optionId, index) !== false,
+        },
+        true
+      );
+    });
+  }
+  if (variables && variables.length) {
+    variables.forEach((variableId) => {
+      watchUpdateVariableInputCondition(
+        mpi,
+        next,
+        {
+          type: UPDATE_VARIABLE_CONDITION,
+          id: variableId,
+          index,
+          value: selectVariableConditionValue(variableId, index) !== false,
+        },
+        true
+      );
+    });
+  }
+};
+
+/**
+ * Watching FETCH_MODEL_SUCCEEDED action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchFetchModelSucceeded = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.App.fetchModelSucceeded
+) => {
+  next(action);
+
+  // Initiating mandatory sections
+  Object.keys(selectAllSectionsReferences() || {}).forEach((id) => {
+    validateSectionMandatory(mpi, parseInt(id, 10));
+  });
+};
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [UPDATE_OPTION_INPUT]: watchUpdateOptionInputCondition,
+  [UPDATE_OPTION_CONDITION]: watchUpdateOptionInputCondition,
+  [UPDATE_VARIABLE_INPUT]: watchUpdateVariableInputCondition,
+  [UPDATE_VARIABLE_CONDITION]: watchUpdateVariableInputCondition,
+  [ADD_MULTIPLE_OCCURENCY]: watchSectionMandatory,
+  [DELETE_MULTIPLE_OCCURENCY]: watchSectionMandatory,
+  [SET_MANDATORY_OPTION]: watchSectionMandatory,
+  [SET_MANDATORY_VARIABLE]: watchSectionMandatory,
+  [UPDATE_SECTION_CONDITION]: watchSectionMandatory,
+  [FETCH_MODEL_SUCCEEDED]: watchFetchModelSucceeded,
+};
+
+/**
+ * Condition Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const mandatoriesWatcherMiddleware =
+  (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => {
+    if (Object.prototype.hasOwnProperty.call(watchersEnum, action.type)) {
+      return watchersEnum[action.type].apply(null, [mpi, next, action]);
+    }
+    return next(action);
+  };
+
+export default mandatoriesWatcherMiddleware;

package/src/redux/middlewares/multiplesActionsMiddleware.test.ts

@@ -0,0 +1,230 @@
+import multiplesActionsMiddleware from './multiplesActionsMiddleware';
+import {
+  addMultipleOccurencyAction,
+  deleteMultipleOccurencyAction,
+} from '../actions/inputs';
+import { StateType } from '../../types/State.type';
+
+// Mocking MPI
+const mpi = {
+  dispatch: jest.fn(),
+  getState: () => ({
+    conditions: {
+      prefillers: {
+        '3': [[false, false, false]],
+      },
+    },
+  }),
+};
+
+// Mocking Next
+const next = jest.fn();
+
+const mockVariablesReferences: StateType.References.Variables = {
+  3: {
+    id: 3,
+    label: 'Variable',
+    type: 'textarea',
+    step: '*',
+    prefillings: [
+      {
+        value: 'Option 4 selected',
+        conditions: {
+          selected: [
+            {
+              var: 'o.4',
+            },
+          ],
+        },
+      },
+      {
+        value: 'Option 3 selected',
+        conditions: {
+          selected: [
+            {
+              var: 'o.3',
+            },
+          ],
+        },
+      },
+      {
+        value: 'Variable 1 = Hello',
+        conditions: {
+          contains: [
+            {
+              var: 'v.1',
+            },
+            'Hello',
+          ],
+        },
+      },
+    ],
+  },
+};
+
+const mockOptionsRelations: StateType.References.Relations['options'] = {
+  2: {
+    options: [],
+    variables: [],
+    sections: {},
+    documents: [],
+    prefillers: [],
+    validators: {
+      options: [],
+      variables: [],
+    },
+    parents: [],
+    children: {
+      options: [3, 4],
+      variables: [2, 3],
+    },
+    dependants: [7, 8],
+  },
+};
+
+const mockOptionsReferences: StateType.References.Options = {
+  2: {
+    meta: {
+      id: 2,
+      type: 'static',
+      label: 'Multiple question',
+      step: '*',
+      tags: [],
+      defaultRadio: 4,
+      multiple: {
+        enabled: true,
+      },
+      validator: {},
+    },
+    options: [3, 4],
+    variables: [2, 3],
+  },
+  3: {
+    meta: {
+      id: 3,
+      type: 'radio',
+      label: 'Option 1',
+      step: '*',
+      tags: [],
+      defaultRadio: 0,
+      validator: {},
+    },
+    options: [],
+    variables: [],
+  },
+  4: {
+    meta: {
+      id: 4,
+      type: 'radio',
+      label: 'Option 2',
+      step: '*',
+      tags: [],
+      defaultRadio: 0,
+      validator: {},
+    },
+    options: [],
+    variables: [],
+  },
+  7: {
+    meta: {
+      id: 4,
+      type: 'hidden',
+      label: 'Option 2',
+      step: '*',
+      tags: [],
+      defaultRadio: 0,
+      validator: {},
+    },
+    options: [],
+    variables: [],
+  },
+  8: {
+    meta: {
+      id: 4,
+      type: 'hidden',
+      label: 'Option 2',
+      step: '*',
+      tags: [],
+      defaultRadio: 0,
+      validator: {},
+    },
+    options: [],
+    variables: [],
+  },
+};
+
+// Mocking reference selecteor
+// ../selectors/references.ts
+jest.mock('../selectors/references', () => ({
+  __esModule: true,
+  selectVariableReference: (id: number) => mockVariablesReferences[id],
+  selectOptionRelations: (id: number) => mockOptionsRelations[id],
+  selectOptionReference: (id: number) => mockOptionsReferences[id],
+}));
+
+describe('Prefillers Watcher Middleware Test suit', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('Completes ADD_MULTIPLE_OCCURENCY action correctly', () => {
+    // Running watcher
+    multiplesActionsMiddleware(mpi)(next)(addMultipleOccurencyAction(2));
+
+    expect(next.mock.calls.length).toBe(1);
+    expect(next.mock.calls[0][0]).toStrictEqual({
+      type: 'ADD_MULTIPLE_OCCURENCY',
+      id: 2,
+      optionRelations: mockOptionsRelations[2],
+      optionsReferences: mockOptionsReferences,
+      prefillersVariables: {
+        '3': [
+          {
+            value: 'Option 4 selected',
+            conditions: {
+              selected: [
+                {
+                  var: 'o.4',
+                },
+              ],
+            },
+          },
+          {
+            value: 'Option 3 selected',
+            conditions: {
+              selected: [
+                {
+                  var: 'o.3',
+                },
+              ],
+            },
+          },
+          {
+            value: 'Variable 1 = Hello',
+            conditions: {
+              contains: [
+                {
+                  var: 'v.1',
+                },
+                'Hello',
+              ],
+            },
+          },
+        ],
+      },
+    });
+  });
+
+  it('Completes DELETE_MULTIPLE_OCCURENCY action correctly', () => {
+    // Running watcher
+    multiplesActionsMiddleware(mpi)(next)(deleteMultipleOccurencyAction(2, 3));
+
+    expect(next.mock.calls.length).toBe(1);
+    expect(next.mock.calls[0][0]).toStrictEqual({
+      type: 'DELETE_MULTIPLE_OCCURENCY',
+      id: 2,
+      index: 3,
+      optionRelations: mockOptionsRelations[2],
+    });
+  });
+});