@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/middlewares/multiplesActionsMiddleware.ts

@@ -0,0 +1,121 @@
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { ActionsType } from '../../types/Actions.type';
+import {
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+} from '../constants/inputs';
+import {
+  selectOptionRelations,
+  selectOptionReference,
+  selectVariableReference,
+} from '../selectors/references';
+import { StateType } from '../../types/State.type';
+
+export type WatcherActions =
+  | ActionsType.Inputs.addMultipleOccurency
+  | ActionsType.Inputs.deleteMultipleOccurency;
+
+/**
+ * Watching ADD_MULTIPLE_OCCURENCY action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const completeAddMultipleOccurency = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.addMultipleOccurency
+) => {
+  const { id } = action;
+
+  // Getting option relations
+  const optionRelations = selectOptionRelations(id);
+  const optionsIds: number[] = [
+    id,
+    ...optionRelations.children.options,
+    ...optionRelations.dependants,
+  ];
+
+  // Getting options references
+  const optionsReferences: Record<string, StateType.References.Options.Option> =
+    {};
+  optionsIds.forEach((currentOptionId) => {
+    optionsReferences[currentOptionId] = selectOptionReference(currentOptionId);
+  });
+
+  // Getting prefillers variables
+  const statePrefillers = mpi.getState().conditions.prefillers;
+  const conditionnedPrefillers = Object.keys(statePrefillers).map((currentId) =>
+    parseInt(currentId, 10)
+  );
+  const prefillersIds: number[] = optionRelations.children.variables.filter(
+    (currentId) => conditionnedPrefillers.includes(currentId)
+  );
+  const prefillersVariables: Record<
+    string,
+    StateType.References.Variables.Variable['prefillings']
+  > = {};
+  prefillersIds.forEach((currentVariableId) => {
+    prefillersVariables[currentVariableId] =
+      selectVariableReference(currentVariableId).prefillings;
+  });
+
+  // Completed Action
+  const completedAction: ActionsType.Inputs.addMultipleOccurency = {
+    ...action,
+    optionRelations,
+    optionsReferences,
+    prefillersVariables,
+  };
+
+  next(completedAction);
+};
+
+/**
+ * Watching ADD_MULTIPLE_OCCURENCY action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const completeDeleteMultipleOccurency = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.addMultipleOccurency
+) => {
+  const { id } = action;
+
+  // Getting option relations
+  const optionRelations = selectOptionRelations(id);
+
+  // Completed Action
+  const completedAction: ActionsType.Inputs.addMultipleOccurency = {
+    ...action,
+    optionRelations,
+  };
+
+  next(completedAction);
+};
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [ADD_MULTIPLE_OCCURENCY]: completeAddMultipleOccurency,
+  [DELETE_MULTIPLE_OCCURENCY]: completeDeleteMultipleOccurency,
+};
+
+/**
+ * Multiples actions Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const multiplesActionsMiddleware =
+  (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 multiplesActionsMiddleware;

package/src/redux/middlewares/paginationWatcherMiddleware.ts

@@ -0,0 +1,251 @@
+import { LocationChangeAction, LOCATION_CHANGE } from 'connected-react-router';
+
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { ActionsType } from '../../types/Actions.type';
+import {
+  goPageAction,
+  updateAvailableSectionsAction,
+  initMetaAction,
+  initInstanceAction,
+} from '../actions/app';
+import { UPDATE_SECTION_CONDITION } from '../constants/conditions';
+import {
+  selectAllSectionsReferences,
+  selectUserEmailSectionVariableIds,
+} from '../selectors/references';
+import { selectSectionConditionValue } from '../selectors/conditions';
+import { isLevelAccessibleForUser, selectUserEmail } from '../selectors/user';
+import {
+  selectAvailableSections,
+  selectPermalink,
+  selectCurrentPage,
+  isStepAvailable,
+  selectCurrentSectionId,
+} from '../selectors/app';
+import {
+  GO_PAGE,
+  GO_NEXT_PAGE,
+  GO_PREVIOUS_PAGE,
+  FETCH_MODEL_SUCCEEDED,
+} from '../constants/app';
+import { getHistory } from '../routerHistory';
+import { StateType } from '../../types/State.type';
+import { PathReader } from '../../libs/PathReader';
+import { selectVariableInputByIndex } from '../selectors/inputs';
+import { setUserEmail } from '../actions/sagas/user';
+
+export type WatcherActions =
+  | ActionsType.Conditions.updateSectionCondition
+  | LocationChangeAction;
+
+/**
+ * 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
+) => {
+  const result = next(action);
+
+  const pathReader = new PathReader(mpi.getState());
+  mpi.dispatch(goPageAction(pathReader.currentPage, false));
+
+  return result;
+};
+
+/**
+ * Watching @@router/LOCATION_CHANGE action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchLocationChange = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateOptionInput
+) => {
+  const result = next(action);
+
+  const pathReader = new PathReader(mpi.getState());
+
+  if (selectPermalink() === '') {
+    mpi.dispatch(
+      initMetaAction({
+        permalink: pathReader.currentPermalink,
+        prefix: pathReader.prefix,
+        id: 0,
+        title: '',
+        modelVersion: 0,
+        productType: '',
+      })
+    );
+
+    if (pathReader.currentUniqid !== undefined) {
+      // Dispatching instance
+      mpi.dispatch(
+        initInstanceAction({
+          dataStatus: 'saved',
+          uniqid: pathReader.currentUniqid,
+          // TODO: Check this one
+          steps: [1],
+        })
+      );
+    }
+  }
+
+  // If previousState is defined, we dispatch a goPage action
+  mpi.dispatch(goPageAction(pathReader.currentPage, false));
+
+  // Setting default values
+  mpi.dispatch({ type: 'SET_DEFAULTS' });
+
+  return result;
+};
+
+/**
+ * Watching @@router/LOCATION_CHANGE action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchSectionConditionUpdate = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateOptionInput
+) => {
+  const result = next(action);
+  const sectionsReferences = selectAllSectionsReferences();
+  if (sectionsReferences === undefined)
+    throw new Error(`Sections references not found`);
+
+  const availableSections = Object.keys(sectionsReferences)
+    .filter((sectionId) => {
+      const condition =
+        selectSectionConditionValue(parseInt(sectionId, 10)) !== false;
+      const sectionReference = sectionsReferences[sectionId];
+      const sectionGrantLevel = sectionReference.grantLevel
+        ? sectionReference.grantLevel
+        : 'GUEST';
+      const grant = isLevelAccessibleForUser(sectionGrantLevel);
+      const availableStep = isStepAvailable(sectionReference.step);
+      return condition && grant && availableStep;
+    })
+    .map((c) => parseInt(c, 10));
+
+  const currentAvailableSectionsReduced = selectAvailableSections().reduce(
+    (p: string, c: number) => `${p} ${c.toString()}`,
+    ''
+  );
+  const nextvailableSectionsReduced = availableSections.reduce(
+    (p: string, c: number) => `${p} ${c.toString()}`,
+    ''
+  );
+
+  if (currentAvailableSectionsReduced !== nextvailableSectionsReduced) {
+    mpi.dispatch(updateAvailableSectionsAction(availableSections));
+  }
+
+  return result;
+};
+
+/**
+ * Watching GO_PAGE action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchGoPage = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.App.goPage
+) => {
+  // If we're in the wizard, let's dispatch SET_DEFAULTS
+  const state: StateType = mpi.getState();
+  if (state.app.pagination.currentAppState === 'wizard') {
+    mpi.dispatch({ type: 'SET_DEFAULTS' });
+  }
+
+  // Executing the action
+  const result = next(action);
+
+  // Pushing to History if necessary
+  if (action.pushHistory === true) {
+    const pathReader = new PathReader(mpi.getState());
+    const currentPage = selectCurrentPage();
+    const path = pathReader.parsePath(currentPage);
+
+    getHistory().push(path);
+  }
+
+  return result;
+};
+
+/**
+ * Watching GO_NEXT_PAGE & GO_PREVIOUS_PAGE action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchNextPreviousPage = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.App.goPage
+) => {
+  // If we're in the wizard, let's dispatch SET_DEFAULTS
+  const state: StateType = mpi.getState();
+  if (state.app.pagination.currentAppState === 'wizard') {
+    mpi.dispatch({ type: 'SET_DEFAULTS' });
+  }
+  const sectionUserEmailVariables = selectUserEmailSectionVariableIds(
+    selectCurrentSectionId()
+  );
+  if (sectionUserEmailVariables.length && !selectUserEmail()) {
+    const [firstUserEmailVariable] = sectionUserEmailVariables;
+    const userEmail = selectVariableInputByIndex(
+      parseInt(firstUserEmailVariable, 10),
+      0
+    ) as string;
+    mpi.dispatch(setUserEmail(userEmail, true, true));
+  }
+  // Executing the action
+  const result = next(action);
+  const pathReader = new PathReader(mpi.getState());
+
+  const path = pathReader.parsePath(selectCurrentPage());
+
+  getHistory().push(path);
+
+  return result;
+};
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [LOCATION_CHANGE]: watchLocationChange,
+  [UPDATE_SECTION_CONDITION]: watchSectionConditionUpdate,
+  [GO_PAGE]: watchGoPage,
+  [GO_NEXT_PAGE]: watchNextPreviousPage,
+  [GO_PREVIOUS_PAGE]: watchNextPreviousPage,
+  [FETCH_MODEL_SUCCEEDED]: watchFetchModelSucceeded,
+};
+
+/**
+ * Pagination Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const paginationWatcherMiddleware =
+  (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 paginationWatcherMiddleware;

package/src/redux/middlewares/pluginsHookMiddleware.ts

@@ -0,0 +1,24 @@
+/* eslint-disable max-len */
+import { MiddlewareAPI, Dispatch, Action } from 'redux';
+import { RunActionAnchor, RunOverrideActionAnchor } from '../../PluginLoader';
+
+/**
+ * Prefiller Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const pluginsHookMiddleware =
+  (mpi: MiddlewareAPI) => (next: Dispatch) => (action: Action) => {
+    const previousState = mpi.getState();
+    const overridenAction = RunOverrideActionAnchor(action);
+    const nextResult = next(overridenAction);
+    const nextState = mpi.getState();
+
+    // Running anchors
+    RunActionAnchor(action.type, previousState, nextState);
+
+    return nextResult;
+  };
+
+export default pluginsHookMiddleware;

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

@@ -0,0 +1,118 @@
+import prefillerWatcherMiddleware from './prefillerWatcherMiddleware';
+import { updatePrefillersConditionsAction } from '../actions/conditions';
+import { StateType } from '../../types/State.type';
+
+// Mocking MPI
+const mpi = {
+  dispatch: jest.fn(),
+  getState: jest.fn(),
+};
+
+// Mocking Next
+const next = jest.fn();
+
+const mockVariablesInputs: Record<string, any[]> = {
+  3: ['Option 4 selected', 'Random text'],
+};
+
+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',
+          ],
+        },
+      },
+    ],
+  },
+};
+
+// Mocking input selecteor
+// ../selectors/inputs.ts
+jest.mock('../selectors/inputs', () => ({
+  __esModule: true,
+  selectVariableInputByIndex: (id: number, index: number) =>
+    mockVariablesInputs[id][index],
+}));
+
+// Mocking reference selecteor
+// ../selectors/references.ts
+jest.mock('../selectors/references', () => ({
+  __esModule: true,
+  selectVariableReference: (id: number) => mockVariablesReferences[id],
+}));
+
+describe('Prefillers Watcher Middleware Test suit', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('Updates variables properly if prefillers conditions changed', () => {
+    // Running watcher
+    prefillerWatcherMiddleware(mpi)(next)(
+      updatePrefillersConditionsAction(3, 0, [false, false, true])
+    );
+
+    expect(mpi.dispatch.mock.calls[0][0]).toStrictEqual({
+      type: 'UPDATE_VARIABLE_INPUT',
+      id: 3,
+      value: 'Variable 1 = Hello',
+      index: 0,
+    });
+  });
+
+  it('Should throw an error if variable does not exist', () => {
+    // Running watcher
+    expect(() =>
+      prefillerWatcherMiddleware(mpi)(next)(
+        updatePrefillersConditionsAction(13243, 0, [true, false, false])
+      )
+    ).toThrowError('Variable 13243 does not exist');
+  });
+
+  it('Should not send update variable value if value is already equal to the prefiller', () => {
+    // Running watcher
+    prefillerWatcherMiddleware(mpi)(next)(
+      updatePrefillersConditionsAction(3, 0, [true, false, false])
+    );
+    expect(mpi.dispatch.mock.calls.length).toEqual(0);
+  });
+
+  it('Should not send update variable value if value has been changed by user', () => {
+    // Running watcher
+    prefillerWatcherMiddleware(mpi)(next)(
+      updatePrefillersConditionsAction(3, 1, [true, true, true])
+    );
+    expect(mpi.dispatch.mock.calls.length).toEqual(0);
+  });
+});