@legalplace/wizardx-core 2.6.4 → 2.7.1

package/src/redux/middlewares/mandatoriesWatcherMiddleware.ts

@@ -1,473 +0,0 @@
-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) => 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

@@ -1,230 +0,0 @@
-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],
-    });
-  });
-});