@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/reducers/conditions/addMultipleOccurency.ts

@@ -0,0 +1,155 @@
+import ConditionsMapper from '@legalplace/referencesparser/dist/libs/ConditionsMapper';
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const addMultipleOccurencyReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Inputs.addMultipleOccurency
+): StateType.Conditions => {
+  const { id, optionRelations, prefillersVariables } = action;
+
+  if (optionRelations === undefined || prefillersVariables === undefined)
+    throw new Error(
+      'ADD_MULTIPLE_OCCURENCY reducer did not recieve complete data when adding ' +
+        `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+
+  // Getting multiple children
+  const conditionnedOptions = Object.keys(state.options).map((currentId) =>
+    parseInt(currentId, 10)
+  );
+  const conditionnedVariables = Object.keys(state.variables).map((currentId) =>
+    parseInt(currentId, 10)
+  );
+  const conditionnedOptionsValidators = Object.keys(
+    state.validators.options
+  ).map((currentId) => parseInt(currentId, 10));
+  const conditionnedVariablesValidators = Object.keys(
+    state.validators.variables
+  ).map((currentId) => parseInt(currentId, 10));
+  const conditionnedPrefillers = Object.keys(state.prefillers).map(
+    (currentId) => parseInt(currentId, 10)
+  );
+
+  // Related conditionned options
+  const optionsIds: number[] = [
+    id,
+    ...optionRelations.children.options,
+    ...optionRelations.dependants,
+  ].filter((currentId) => conditionnedOptions.includes(currentId));
+
+  // Related conditionned variables
+  const variablesIds: number[] = optionRelations.children.variables.filter(
+    (currentId) => conditionnedVariables.includes(currentId)
+  );
+
+  // Related options validators
+  const optionsValidatorsIds: number[] =
+    optionRelations.children.options.filter((currentId) =>
+      conditionnedOptionsValidators.includes(currentId)
+    );
+
+  // Related variables validators
+  const variablesValidatorsIds: number[] =
+    optionRelations.children.variables.filter((currentId) =>
+      conditionnedVariablesValidators.includes(currentId)
+    );
+
+  // Related prefillers
+  const prefillersIds: number[] = optionRelations.children.variables.filter(
+    (currentId) => conditionnedPrefillers.includes(currentId)
+  );
+
+  /**
+   * Options conditions
+   */
+  const options: StateType.Conditions.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    options[currentOptionId] = [...state.options[currentOptionId], false];
+  });
+
+  /**
+   * Variables conditions
+   */
+  const variables: StateType.Conditions.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    variables[currentVariableId] = [
+      ...state.variables[currentVariableId],
+      false,
+    ];
+  });
+
+  /**
+   * Options validators
+   */
+  const optionsValidators: StateType.Conditions.Validators.Options = {};
+  optionsValidatorsIds.forEach((currentOptionId) => {
+    optionsValidators[currentOptionId] = [
+      ...state.validators.options[currentOptionId],
+      false,
+    ];
+  });
+
+  /**
+   * Variables validators
+   */
+  const variablesValidators: StateType.Conditions.Validators.Variables = {};
+  variablesValidatorsIds.forEach((currentVariableId) => {
+    variablesValidators[currentVariableId] = [
+      ...state.validators.variables[currentVariableId],
+      false,
+    ];
+  });
+
+  /**
+   * Prefillers conditions
+   */
+  const prefillers: StateType.Conditions.Prefillers = {};
+  prefillersIds.forEach((currentVariableId) => {
+    const variablePrefillings = prefillersVariables[currentVariableId];
+    const defaultPrefillersValues = Array.isArray(variablePrefillings)
+      ? new Array(variablePrefillings.length).fill(false)
+      : [true];
+
+    variablePrefillings?.forEach((prefilling, index) => {
+      if (
+        !prefilling.conditions ||
+        (prefilling.conditions &&
+          ConditionsMapper.countConditions(prefilling.conditions) === 0)
+      )
+        defaultPrefillersValues[index] = true;
+    });
+
+    prefillers[currentVariableId] = [
+      ...state.prefillers[currentVariableId],
+      defaultPrefillersValues,
+    ];
+  });
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    prefillers: {
+      ...state.prefillers,
+      ...prefillers,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+    validators: {
+      options: {
+        ...state.validators.options,
+        ...optionsValidators,
+      },
+      variables: {
+        ...state.validators.variables,
+        ...variablesValidators,
+      },
+    },
+  };
+};

package/src/redux/reducers/conditions/deleteMultipleOccurency.test.ts

@@ -0,0 +1,95 @@
+import { deleteMultipleOccurencyReducer } from './deleteMultipleOccurency';
+import { StateType } from '../../../types/State.type';
+
+const state: StateType.Conditions = {
+  options: {
+    4: [true, false, true],
+  },
+  variables: {
+    2: [false, true, false],
+  },
+  validators: {
+    options: {
+      4: [false, false, true],
+    },
+    variables: {
+      3: [true, false, true],
+    },
+  },
+  documents: {},
+  sections: {},
+  prefillers: {
+    3: [
+      [true, false, false],
+      [false, true, false],
+      [false, false, true],
+    ],
+  },
+};
+
+describe('deleteMultipleOccurencyReducer test suit', () => {
+  it('Throws an error if optionRelations or prefillersVariables are undefined', () => {
+    expect(() => {
+      // @ts-ignore: Done on purpose to make sure function validates input
+      deleteMultipleOccurencyReducer(state, {
+        id: 3,
+        optionRelations: undefined,
+      });
+    }).toThrowError(
+      'DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing occurency for 3,' +
+        ' please make sure "multiplesActions" middleware is plugged and working properly'
+    );
+  });
+
+  it('Adds a multiple occurency conditions correctly', () => {
+    const optionRelations = {
+      options: [],
+      variables: [],
+      sections: {},
+      documents: [],
+      prefillers: [],
+      validators: {
+        options: [],
+        variables: [],
+      },
+      parents: [],
+      children: {
+        options: [3, 4],
+        variables: [2, 3],
+      },
+      dependants: [7, 8],
+    };
+
+    const reducerResult = deleteMultipleOccurencyReducer(state, {
+      id: 2,
+      index: 1,
+      optionRelations,
+      type: 'DELETE_MULTIPLE_OCCURENCY',
+    });
+
+    expect(reducerResult).toStrictEqual({
+      ...state,
+      options: {
+        ...state.options,
+        4: [true, true],
+      },
+      variables: {
+        2: [false, false],
+      },
+      prefillers: {
+        3: [
+          [true, false, false],
+          [false, false, true],
+        ],
+      },
+      validators: {
+        options: {
+          4: [false, true],
+        },
+        variables: {
+          3: [true, true],
+        },
+      },
+    });
+  });
+});

package/src/redux/reducers/conditions/deleteMultipleOccurency.ts

@@ -0,0 +1,141 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const deleteMultipleOccurencyReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Inputs.deleteMultipleOccurency
+): StateType.Conditions => {
+  const { id, index, optionRelations } = action;
+
+  if (optionRelations === undefined)
+    throw new Error(
+      'DELETE_MULTIPLE_OCCURENCY reducer did not recieve complete data when removing ' +
+        `occurency for ${id}, please make sure "multiplesActions" middleware is ` +
+        'plugged and working properly'
+    );
+
+  // Getting multiple children
+  const conditionnedOptions = Object.keys(state.options).map((currentId) =>
+    parseInt(currentId, 10)
+  );
+  const conditionnedVariables = Object.keys(state.variables).map((currentId) =>
+    parseInt(currentId, 10)
+  );
+  const conditionnedOptionsValidators = Object.keys(
+    state.validators.options
+  ).map((currentId) => parseInt(currentId, 10));
+  const conditionnedVariablesValidators = Object.keys(
+    state.validators.variables
+  ).map((currentId) => parseInt(currentId, 10));
+  const conditionnedPrefillers = Object.keys(state.prefillers).map(
+    (currentId) => parseInt(currentId, 10)
+  );
+
+  // Related conditionned options
+  const optionsIds: number[] = [id, ...optionRelations.children.options].filter(
+    (currentId) => conditionnedOptions.includes(currentId)
+  );
+
+  // Related conditionned variables
+  const variablesIds: number[] = optionRelations.children.variables.filter(
+    (currentId) => conditionnedVariables.includes(currentId)
+  );
+
+  // Related options validators
+  const optionsValidatorsIds: number[] =
+    optionRelations.children.options.filter((currentId) =>
+      conditionnedOptionsValidators.includes(currentId)
+    );
+
+  // Related variables validators
+  const variablesValidatorsIds: number[] =
+    optionRelations.children.variables.filter((currentId) =>
+      conditionnedVariablesValidators.includes(currentId)
+    );
+
+  // Related prefillers
+  const prefillersIds: number[] = optionRelations.children.variables.filter(
+    (currentId) => conditionnedPrefillers.includes(currentId)
+  );
+
+  /**
+   * Options conditions
+   */
+  const options: StateType.Conditions.Options = {};
+  optionsIds.forEach((currentOptionId) => {
+    options[currentOptionId] = [
+      ...state.options[currentOptionId].slice(0, index),
+      ...state.options[currentOptionId].slice(index + 1),
+    ];
+  });
+
+  /**
+   * Variables conditions
+   */
+  const variables: StateType.Conditions.Variables = {};
+  variablesIds.forEach((currentVariableId) => {
+    variables[currentVariableId] = [
+      ...state.variables[currentVariableId].slice(0, index),
+      ...state.variables[currentVariableId].slice(index + 1),
+    ];
+  });
+
+  /**
+   * Options validators
+   */
+  const optionsValidators: StateType.Conditions.Validators.Options = {};
+  optionsValidatorsIds.forEach((currentOptionId) => {
+    optionsValidators[currentOptionId] = [
+      ...state.validators.options[currentOptionId].slice(0, index),
+      ...state.validators.options[currentOptionId].slice(index + 1),
+    ];
+  });
+
+  /**
+   * Variables validators
+   */
+  const variablesValidators: StateType.Conditions.Validators.Variables = {};
+  variablesValidatorsIds.forEach((currentVariableId) => {
+    variablesValidators[currentVariableId] = [
+      ...state.validators.variables[currentVariableId].slice(0, index),
+      ...state.validators.variables[currentVariableId].slice(index + 1),
+    ];
+  });
+
+  /**
+   * Options validators
+   */
+  const prefillers: StateType.Conditions.Prefillers = {};
+  prefillersIds.forEach((currentVariableId) => {
+    prefillers[currentVariableId] = [
+      ...state.prefillers[currentVariableId].slice(0, index),
+      ...state.prefillers[currentVariableId].slice(index + 1),
+    ];
+  });
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      ...variables,
+    },
+    prefillers: {
+      ...state.prefillers,
+      ...prefillers,
+    },
+    options: {
+      ...state.options,
+      ...options,
+    },
+    validators: {
+      options: {
+        ...state.validators.options,
+        ...optionsValidators,
+      },
+      variables: {
+        ...state.validators.variables,
+        ...variablesValidators,
+      },
+    },
+  };
+};

package/src/redux/reducers/conditions/initConditions.ts

@@ -0,0 +1,18 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const initConditionsReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.initConditions
+): StateType.Conditions => {
+  const { options, variables, sections, prefillers, validators, documents } =
+    action;
+  return {
+    options,
+    variables,
+    sections,
+    prefillers,
+    validators,
+    documents,
+  };
+};

package/src/redux/reducers/conditions/updateDocumentConditions.test.ts

@@ -0,0 +1,47 @@
+import { updateDocumentConditionReducer } from './updateDocumentConditions';
+import { StateType } from '../../../types/State.type';
+import { UPDATE_DOCUMENT_CONDITION } from '../../constants/conditions';
+
+const state: StateType.Conditions = {
+  options: {},
+  variables: {},
+  validators: {
+    options: {},
+    variables: {},
+  },
+  documents: {
+    'test-document-1': true,
+    'test-document-2': false,
+    'test-document-3': true,
+  },
+  sections: {},
+  prefillers: {},
+};
+
+describe('updateDocumentConditionReducer test suit', () => {
+  it('Updates document condition properly', () => {
+    const reducerResult = updateDocumentConditionReducer(state, {
+      type: UPDATE_DOCUMENT_CONDITION,
+      name: 'test-document-2',
+      value: true,
+    });
+
+    expect(reducerResult).toStrictEqual({
+      ...state,
+      documents: {
+        ...state.documents,
+        'test-document-2': true,
+      },
+    });
+  });
+
+  it('Returns same state without touching references if condition did not change', () => {
+    const reducerResult = updateDocumentConditionReducer(state, {
+      type: UPDATE_DOCUMENT_CONDITION,
+      name: 'test-document-2',
+      value: false,
+    });
+
+    expect(reducerResult).toEqual(state);
+  });
+});

package/src/redux/reducers/conditions/updateDocumentConditions.ts

@@ -0,0 +1,21 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+// eslint-disable-next-line max-len
+export const updateDocumentConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateDocumentCondition
+): StateType.Conditions => {
+  const { name, value } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.documents[name] === value) return state;
+
+  return {
+    ...state,
+    documents: {
+      ...state.documents,
+      [name]: value,
+    },
+  };
+};

package/src/redux/reducers/conditions/updateOptionConditions.ts

@@ -0,0 +1,24 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateOptionConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateOptionCondition
+): StateType.Conditions => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.options[id][index] === value) return state;
+
+  return {
+    ...state,
+    options: {
+      ...state.options,
+      [id]: [
+        ...state.options[id].slice(0, index),
+        value,
+        ...state.options[id].slice(index + 1),
+      ],
+    },
+  };
+};

package/src/redux/reducers/conditions/updateOptionValidatorCondition.test.ts

@@ -0,0 +1,50 @@
+import { updateOptionValidatorConditionReducer } from './updateOptionValidatorCondition';
+import { StateType } from '../../../types/State.type';
+import { UPDATE_OPTION_VALIDATOR_CONDITION } from '../../constants/conditions';
+
+const state: StateType.Conditions = {
+  options: {},
+  variables: {},
+  validators: {
+    options: {
+      2: [false, true, false],
+    },
+    variables: {},
+  },
+  documents: {},
+  sections: {},
+  prefillers: {},
+};
+
+describe('updateOptionValidatorConditionReducer test suit', () => {
+  it('Updates option validator condition properly', () => {
+    const reducerResult = updateOptionValidatorConditionReducer(state, {
+      type: UPDATE_OPTION_VALIDATOR_CONDITION,
+      id: 2,
+      index: 1,
+      value: false,
+    });
+
+    expect(reducerResult).toStrictEqual({
+      ...state,
+      validators: {
+        ...state.validators,
+        options: {
+          ...state.validators.options,
+          2: [false, false, false],
+        },
+      },
+    });
+  });
+
+  it('Returns same state without touching references if condition did not change', () => {
+    const reducerResult = updateOptionValidatorConditionReducer(state, {
+      type: UPDATE_OPTION_VALIDATOR_CONDITION,
+      id: 2,
+      index: 1,
+      value: true,
+    });
+
+    expect(reducerResult).toEqual(state);
+  });
+});

package/src/redux/reducers/conditions/updateOptionValidatorCondition.ts

@@ -0,0 +1,28 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+// eslint-disable-next-line max-len
+export const updateOptionValidatorConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateOptionValidatorCondition
+): StateType.Conditions => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.validators.options[id][index] === value) return state;
+
+  return {
+    ...state,
+    validators: {
+      ...state.validators,
+      options: {
+        ...state.validators.options,
+        [id]: [
+          ...state.validators.options[id].slice(0, index),
+          value,
+          ...state.validators.options[id].slice(index + 1),
+        ],
+      },
+    },
+  };
+};

package/src/redux/reducers/conditions/updatePrefillerConditions.ts

@@ -0,0 +1,29 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updatePrefillerConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updatePrefillerCondition
+): StateType.Conditions => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (
+    !state.prefillers[id][index] ||
+    state.prefillers[id][index].reduce((v, p) => v + p, '') ===
+      value.reduce((v, p) => v + p, '')
+  )
+    return state;
+
+  return {
+    ...state,
+    prefillers: {
+      ...state.prefillers,
+      [id]: [
+        ...state.prefillers[id].slice(0, index),
+        value,
+        ...state.prefillers[id].slice(index + 1),
+      ],
+    },
+  };
+};

package/src/redux/reducers/conditions/updateSectionConditions.ts

@@ -0,0 +1,28 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+export const updateSectionConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateSectionCondition
+): StateType.Conditions => {
+  const { id, value, document } = action;
+
+  // If ID is equal -1 let's stop here,
+  // this is used to trigger pagination
+  // middleware to reorder availableSections
+  if (id === -1) return state;
+
+  // Making sure value has changed before changing the state
+  if (state.sections[document][id] === value) return state;
+
+  return {
+    ...state,
+    sections: {
+      ...state.sections,
+      [document]: {
+        ...state.sections[document],
+        [id]: value,
+      },
+    },
+  };
+};

package/src/redux/reducers/conditions/updateVariableConditions.ts

@@ -0,0 +1,25 @@
+import { ActionsType } from '../../../types/Actions.type';
+import { StateType } from '../../../types/State.type';
+
+// eslint-disable-next-line max-len
+export const updateVariableConditionReducer = (
+  state: StateType.Conditions,
+  action: ActionsType.Conditions.updateVariableCondition
+): StateType.Conditions => {
+  const { id, value, index } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.variables[id][index] === value) return state;
+
+  return {
+    ...state,
+    variables: {
+      ...state.variables,
+      [id]: [
+        ...state.variables[id].slice(0, index),
+        value,
+        ...state.variables[id].slice(index + 1),
+      ],
+    },
+  };
+};