@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/middlewares/prefillerWatcherMiddleware.ts

@@ -0,0 +1,462 @@
+/* eslint-disable max-len */
+import { MiddlewareAPI, Dispatch } from 'redux';
+import { filterXSS } from 'xss';
+import ConditionsMapper from '@legalplace/referencesparser/dist/libs/ConditionsMapper';
+import { ActionsType } from '../../types/Actions.type';
+import { UPDATE_PREFILLER_CONDITION } from '../constants/conditions';
+import {
+  selectVariableInputByIndex,
+  selectVariableInput,
+  selectOptionInput,
+} from '../selectors/inputs';
+import {
+  areVariablesSiblings,
+  selectOptionRelations,
+  selectVariableReference,
+  selectVariableRelations,
+} from '../selectors/references';
+import { updateVariableAction } from '../actions/inputs';
+import { StateType } from '../../types/State.type';
+import {
+  ADD_MULTIPLE_OCCURENCY,
+  UPDATE_VARIABLE_INPUT,
+} from '../constants/inputs';
+import { selectPrefillerConditionValue } from '../selectors/conditions';
+import { FETCH_MODEL_SUCCEEDED } from '../constants/app';
+
+export type WatcherActions = ActionsType.Conditions.updatePrefillerCondition;
+
+const parsePrefillerValue = (
+  variableId: number,
+  inputIndex: number,
+  prefillerIndex: number
+) => {
+  const prefillerValue =
+    selectVariableReference(variableId)?.prefillings?.[prefillerIndex]?.value;
+
+  if (!prefillerValue) return '';
+
+  if (/\[var:([0-9]+)\]/gi.test(prefillerValue)) {
+    // Extracting variables
+    const tagsMatch = prefillerValue.match(/\[var:([0-9]+)\]/gi);
+    let variables: number[] = [];
+    if (tagsMatch !== null) {
+      // Tranforming tags into integer ids
+      const variablesTags: string[] = [...tagsMatch];
+      variables = variablesTags.map((current) => {
+        const outputVariableMatch = current.match(/([0-9]+)/);
+        if (outputVariableMatch === null) return 0;
+        return parseInt(outputVariableMatch[0], 10);
+      });
+    }
+
+    // Removing duplicated variables
+    variables = variables.filter((c, i) => variables.indexOf(c) === i);
+
+    // Making sure all variables exist
+    variables = variables.filter(
+      (c) => selectVariableReference(c) !== undefined
+    );
+
+    // Getting values
+    const variablesValues: Record<string, string> = {};
+    variables.forEach((currentVariableId) => {
+      const index = areVariablesSiblings(currentVariableId, variableId)
+        ? inputIndex
+        : 0;
+      const value = selectVariableInputByIndex(currentVariableId, index);
+      if (
+        value === undefined ||
+        value === null ||
+        (typeof value === 'string' && value.trim().length === 0)
+      ) {
+        variablesValues[currentVariableId] = '';
+      } else {
+        variablesValues[currentVariableId] = value.toString();
+      }
+    });
+
+    // Inserting values
+    let parsedPrefillerValue = `${prefillerValue}`;
+    variables.forEach((currentVariableId) => {
+      const value: string = variablesValues[currentVariableId];
+      parsedPrefillerValue = parsedPrefillerValue.replace(
+        new RegExp(`\\[var:${currentVariableId}\\]`, 'gi'),
+        filterXSS(value)
+      );
+    });
+
+    // Returning parsed value
+    return parsedPrefillerValue;
+  }
+
+  return prefillerValue;
+};
+
+/**
+ * Watching UPDATE_PREFILLER_CONDITION action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdatePrefillerCondition = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Conditions.updatePrefillerCondition
+) => {
+  const result = next(action);
+
+  // Extracting variable data from the action (the prefiller id is the variable id)
+  const variableId = action.id;
+  const variableIndex = action.index;
+  const prefillerConditions = action.value;
+
+  // Getting variable's reference
+  const variableReference = selectVariableReference(variableId);
+  if (variableReference === undefined)
+    throw new Error(`Variable ${variableId} does not exist`);
+
+  // Getting the index of the first true condition (if none is true -1 means the prefiller is empty)
+  const firstTrueIndex = prefillerConditions.indexOf(true);
+
+  // Getting current variable value
+  let currentValue = selectVariableInputByIndex(variableId, variableIndex);
+  currentValue =
+    typeof currentValue === 'number' ? currentValue.toString() : currentValue;
+  currentValue = typeof currentValue === 'string' ? currentValue : '';
+
+  // Getting first undefined value
+  const firstUnconditionnedIndex = variableReference.prefillings
+    ? variableReference.prefillings
+        .map(
+          (c) =>
+            c.conditions === undefined ||
+            ConditionsMapper.countConditions(c.conditions) === 0
+        )
+        .indexOf(true)
+    : -1;
+
+  // Getting prefillers values
+  let prefillersValues = variableReference.prefillings
+    ? variableReference.prefillings
+    : new Array(prefillerConditions.length).fill('');
+  prefillersValues = prefillersValues.map((prefiller) => prefiller.value);
+
+  // Filling prefillers values with variables
+  prefillersValues = prefillersValues.map((prefillerValue, prefillerIndex) => {
+    // Checking whether prefiller valuecontains a variable
+    if (/\[var:([0-9]+)\]/gi.test(prefillerValue))
+      return parsePrefillerValue(variableId, variableIndex, prefillerIndex);
+
+    // Removing whitespaces from beginning and end of each prefiller value
+    return prefillerValue.replace(/^\s+|\s+$/g, '');
+  });
+
+  // Getting the value to prefill
+  const newPrefillerValue =
+    // eslint-disable-next-line no-nested-ternary
+    firstTrueIndex > -1
+      ? prefillersValues[firstTrueIndex]
+      : firstUnconditionnedIndex > -1
+      ? prefillersValues[firstUnconditionnedIndex]
+      : '';
+
+  // Prefilling the variable if it's current value is empty or equals another prefillers
+  if (
+    currentValue === '' ||
+    (prefillersValues.includes(currentValue) &&
+      currentValue !== newPrefillerValue)
+  ) {
+    mpi.dispatch(
+      updateVariableAction(variableId, newPrefillerValue, variableIndex)
+    );
+  }
+
+  return result;
+};
+
+/**
+ * Watching UPDATE_PREFILLER_CONDITION action
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchAddMultipleOccurency = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.addMultipleOccurency
+) => {
+  const result = next(action);
+
+  // Extracting variable data from the action (the prefiller id is the variable id)
+  const optionId = action.id;
+
+  // Getting child variables
+  const childrenVariables = selectOptionRelations(optionId).children.variables;
+  const variableIndex = selectOptionInput(optionId).length - 1;
+
+  childrenVariables.forEach((variableId) => {
+    // Getting variable's reference
+    const variableReference = selectVariableReference(variableId);
+
+    if (variableReference === undefined)
+      throw new Error(`Variable ${variableId} does not exist`);
+
+    if (
+      variableReference.prefillings?.length &&
+      variableReference.prefillings.length > 0
+    ) {
+      const prefillerConditions =
+        selectPrefillerConditionValue(variableId)?.[variableIndex];
+
+      if (prefillerConditions === undefined) return;
+
+      // Getting the index of the first true condition (if none is true -1 means the prefiller is empty)
+      const firstTrueIndex = prefillerConditions.indexOf(true);
+
+      // Getting current variable value
+      let currentValue = selectVariableInputByIndex(variableId, variableIndex);
+      currentValue =
+        typeof currentValue === 'number'
+          ? currentValue.toString()
+          : currentValue;
+      currentValue = typeof currentValue === 'string' ? currentValue : '';
+      currentValue = currentValue.trim();
+
+      // Getting first undefined value
+      const firstUndefinedCondition = variableReference.prefillings
+        ? variableReference.prefillings
+            .map((c) => c.conditions)
+            .indexOf(undefined)
+        : -1;
+
+      // Getting prefillers values
+      let prefillersValues = variableReference.prefillings
+        ? variableReference.prefillings
+        : new Array(prefillerConditions.length).fill('');
+      prefillersValues = prefillersValues.map((prefiller) => prefiller.value);
+
+      // Filling prefillers values with variables
+      prefillersValues = prefillersValues.map((prefillerValue) => {
+        // Checking whether prefiller valuecontains a variable
+        if (/\[var:([0-9]+)\]/gi.test(prefillerValue)) {
+          // Extracting variables
+          const tagsMatch = prefillerValue.match(/\[var:([0-9]+)\]/gi);
+          let variables: number[] = [];
+          if (tagsMatch !== null) {
+            // Tranforming tags into integer ids
+            const variablesTags: string[] = [...tagsMatch];
+            variables = variablesTags.map((current) => {
+              const outputVariableMatch = current.match(/([0-9]+)/);
+              if (outputVariableMatch === null) return 0;
+              return parseInt(outputVariableMatch[0], 10);
+            });
+          }
+
+          // Removing duplicated variables
+          variables = variables.filter((c, i) => variables.indexOf(c) === i);
+
+          // Making sure all variables exist
+          variables = variables.filter(
+            (c) => selectVariableReference(c) !== undefined
+          );
+
+          // Getting values
+          const variablesValues: Record<string, string> = {};
+          variables.forEach((currentVariableId) => {
+            const index = areVariablesSiblings(currentVariableId, variableId)
+              ? variableIndex
+              : 0;
+            const value = selectVariableInputByIndex(currentVariableId, index);
+            if (
+              value === undefined ||
+              value === null ||
+              (typeof value === 'string' && value.trim().length === 0)
+            ) {
+              variablesValues[currentVariableId] = '';
+            } else {
+              variablesValues[currentVariableId] = value.toString();
+            }
+          });
+
+          // Inserting values
+          let parsedPrefillerValue = `${prefillerValue}`;
+          variables.forEach((currentVariableId) => {
+            const value: string = variablesValues[currentVariableId];
+            parsedPrefillerValue = parsedPrefillerValue.replace(
+              new RegExp(`\\[var:${currentVariableId}\\]`, 'gi'),
+              filterXSS(value)
+            );
+          });
+
+          // Returning parsed value
+          return parsedPrefillerValue;
+        }
+
+        // Removing whitespaces from beginning and end of each prefiller value
+        return prefillerValue.replace(/^\s+|\s+$/g, '');
+      });
+
+      // Getting the value to prefill
+      const newPrefillerValue =
+        // eslint-disable-next-line no-nested-ternary
+        firstTrueIndex > -1
+          ? prefillersValues[firstTrueIndex]
+          : firstUndefinedCondition > -1
+          ? prefillersValues[firstUndefinedCondition]
+          : '';
+
+      // Prefilling the variable if it's current value is empty or equals another prefiller
+      if (
+        currentValue === '' ||
+        (prefillersValues.includes(currentValue) &&
+          currentValue !== newPrefillerValue)
+      ) {
+        mpi.dispatch(
+          updateVariableAction(variableId, newPrefillerValue, variableIndex)
+        );
+      }
+    }
+  });
+
+  return result;
+};
+
+const watchUpdateVariableInput = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateVariableInput,
+  noDispatch = false
+) => {
+  const { id, index } = action;
+
+  // Checking whether prefillers should update
+  const { prefillingsContents } = selectVariableRelations(id);
+
+  // Getting list of prefillers to update
+  const prefillersToUpdate: {
+    variableId: number;
+    inputIndex: number;
+    prefillingIndex: number;
+  }[] = [];
+
+  // NOTE: This should be done before executing "next" action
+  // in order to parse prefilling contents with previous variable
+  // values
+  if (prefillingsContents.length > 0) {
+    prefillingsContents.forEach(({ variableId, prefillingIndex }) => {
+      // Getting relation's current value
+      const relationValues = selectVariableInput(variableId);
+      const relationReference = selectVariableReference(variableId);
+
+      // Going throught relation
+      relationValues.forEach((currentRelationValue, currentRelationIndex) => {
+        // Checking if prefiller and variable are siblings
+        if (
+          areVariablesSiblings(variableId, id) &&
+          currentRelationIndex !== index
+        )
+          return;
+
+        // If current relation's value is equal to the prefiller
+        // we needed
+        if (
+          relationReference.prefillings &&
+          currentRelationValue ===
+            parsePrefillerValue(variableId, index, prefillingIndex)
+        ) {
+          prefillersToUpdate.push({
+            variableId,
+            inputIndex: currentRelationIndex,
+            prefillingIndex,
+          });
+        }
+      });
+    });
+  }
+
+  // Executing action
+  if (noDispatch !== true) next(action);
+
+  // Updating prefillers
+  prefillersToUpdate.forEach(({ variableId, inputIndex, prefillingIndex }) => {
+    const value = parsePrefillerValue(variableId, index, prefillingIndex);
+    mpi.dispatch(updateVariableAction(variableId, value, inputIndex));
+  });
+};
+
+const watchFetchModelSucceeded = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.App.fetchModelSucceeded
+) => {
+  next(action);
+
+  /**
+   * Initiating Prefillers
+   */
+  const { variables } = mpi.getState().inputs;
+
+  // Initiating prefillers with no conditions
+  const { prefillers } = mpi.getState().conditions;
+  Object.keys(prefillers).forEach((variableStrId) => {
+    const variableId = parseInt(variableStrId, 10);
+
+    // Getting prefillers reference
+    const { prefillings } = selectVariableReference(variableId);
+
+    if (Array.isArray(prefillings)) {
+      // Getting first undefined value
+      const firstUnconditionnedIndex = prefillings
+        .map(
+          (c) =>
+            c.conditions === undefined ||
+            ConditionsMapper.countConditions(c.conditions) === 0
+        )
+        .indexOf(true);
+
+      if (firstUnconditionnedIndex > -1) {
+        variables[variableId].forEach((value, variableIndex) => {
+          const prefillerValue = parsePrefillerValue(
+            variableId,
+            variableIndex,
+            firstUnconditionnedIndex
+          );
+
+          if (value.toString().trim().length === 0) {
+            mpi.dispatch(
+              updateVariableAction(variableId, prefillerValue, variableIndex)
+            );
+          }
+        });
+      }
+    }
+  });
+};
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [UPDATE_PREFILLER_CONDITION]: watchUpdatePrefillerCondition,
+  [UPDATE_VARIABLE_INPUT]: watchUpdateVariableInput,
+  [FETCH_MODEL_SUCCEEDED]: watchFetchModelSucceeded,
+  [ADD_MULTIPLE_OCCURENCY]: watchAddMultipleOccurency,
+};
+
+/**
+ * Prefiller Watcher Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const prefillerWatcherMiddleware =
+  (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 prefillerWatcherMiddleware;

package/src/redux/middlewares/smartscriptMiddleware.ts

@@ -0,0 +1,171 @@
+import { MiddlewareAPI, Dispatch } from 'redux';
+import cloneDeep from 'lodash/cloneDeep';
+import { ActionsType } from '../../types/Actions.type';
+import { StateType } from '../../types/State.type';
+import {
+  ADD_MULTIPLE_OCCURENCY,
+  DELETE_MULTIPLE_OCCURENCY,
+  UPDATE_OPTION_INPUT,
+  UPDATE_VARIABLE_INPUT,
+} from '../constants/inputs';
+import { ENABLE_SMARTSCRIPT } from '../constants/smartscript';
+import { PathReader } from '../../libs/PathReader';
+import { initSmartscriptTriggersAction } from '../actions/smartscript';
+
+let iframe: HTMLIFrameElement | null = null;
+
+const watchEnableSmartScript = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: WatcherActions
+) => {
+  next(action);
+
+  // Creating iframe
+  iframe = document.createElement('iframe');
+  iframe.id = 'lp-smartscript';
+  iframe.setAttribute(
+    'style',
+    'position: absolute; width:0; height:0; border:0;'
+  );
+  const { permalink } = mpi.getState().app.meta;
+  const { uniqid } = mpi.getState().app.instance;
+  const { modelVersion } = new PathReader(mpi.getState());
+  iframe.src = `${window.location.protocol}//${
+    window.location.host
+  }/contrats/${permalink}/smartscript/${uniqid || ''}${
+    modelVersion ? `?version=${modelVersion}` : ''
+  }`;
+
+  // Checking if it's a new instance
+  const isNewInstance = !(
+    typeof uniqid === 'string' && uniqid.trim().length > 0
+  );
+
+  // Initiating triggers
+  iframe.onload = () => {
+    iframe?.contentWindow?.initTriggers(
+      (triggers, actions) => {
+        mpi.dispatch(initSmartscriptTriggersAction(triggers));
+        if (Array.isArray(actions)) {
+          actions.forEach((_action) => {
+            mpi.dispatch(_action);
+          });
+        }
+      },
+      cloneDeep(mpi.getState().inputs),
+      isNewInstance
+    );
+  };
+
+  document.body.append(iframe);
+};
+
+/**
+ * Watches option input update
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateOptionInput = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateOptionInput
+) => {
+  next(action);
+
+  // Getting inputs
+  const state = mpi.getState();
+
+  const { id } = action;
+
+  if (state.smartscript.triggers.options.includes(id)) {
+    try {
+      const actions = iframe?.contentWindow?.triggerListeners(
+        'option',
+        id,
+        cloneDeep(state.inputs)
+      );
+
+      if (Array.isArray(actions)) {
+        actions.forEach((_action) => {
+          mpi.dispatch(_action);
+        });
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+    }
+  }
+};
+
+/**
+ * Watches variable input update
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const watchUpdateVariableInput = (
+  mpi: MiddlewareAPI<Dispatch, StateType>,
+  next: Dispatch,
+  action: ActionsType.Inputs.updateVariableInput
+) => {
+  next(action);
+
+  // Getting inputs
+  const state = mpi.getState();
+
+  const { id } = action;
+
+  if (state.smartscript.triggers.variables.includes(id)) {
+    try {
+      const actions = iframe?.contentWindow?.triggerListeners(
+        'variable',
+        id,
+        cloneDeep(state.inputs)
+      );
+
+      if (Array.isArray(actions)) {
+        actions.forEach((_action) => {
+          mpi.dispatch(_action);
+        });
+      }
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.error(e);
+    }
+  }
+};
+
+export type WatcherActions =
+  | ActionsType.SmartScript.enableSmartScript
+  | ActionsType.Inputs.updateOptionInput
+  | ActionsType.Inputs.updateVariableInput;
+
+// Enumerating watchers
+const watchersEnum: Record<
+  string,
+  (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: any) => void
+> = {
+  [ENABLE_SMARTSCRIPT]: watchEnableSmartScript,
+  [UPDATE_OPTION_INPUT]: watchUpdateOptionInput,
+  [UPDATE_VARIABLE_INPUT]: watchUpdateVariableInput,
+  [ADD_MULTIPLE_OCCURENCY]: watchUpdateOptionInput,
+  [DELETE_MULTIPLE_OCCURENCY]: watchUpdateOptionInput,
+};
+
+/**
+ * SmartScript Middleware
+ * @param mpi MiddlewareAPI
+ * @param next Dispatch function
+ * @param action Actions
+ */
+const smartscriptMiddleware =
+  (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 smartscriptMiddleware;

package/src/redux/reducers/app/customizations/initCustomizationAutoDefault.ts

@@ -0,0 +1,16 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const initCustomizationAutoDefaultTypeReducer = (
+  state: StateType.App,
+  action: ActionsType.App.initCustomizationAutoDefault
+): StateType.App => {
+  const { disableAutoDefault } = action;
+  return {
+    ...state,
+    customization: {
+      ...state.customization,
+      disableAutoDefault,
+    },
+  };
+};

package/src/redux/reducers/app/customizations/initCustomizationMeta.ts

@@ -0,0 +1,16 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const initCustomizationMetaReducer = (
+  state: StateType.App,
+  action: ActionsType.App.initCustomizationMeta
+): StateType.App => {
+  const { meta } = action;
+  return {
+    ...state,
+    customization: {
+      ...state.customization,
+      meta,
+    },
+  };
+};

package/src/redux/reducers/app/instance/initInstance.ts

@@ -0,0 +1,29 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const initInstanceReducer = (
+  state: StateType.App,
+  action: ActionsType.App.initInstance
+): StateType.App => {
+  const {
+    uniqid,
+    isPaid,
+    dataStatus,
+    steps,
+    isOrderHandled,
+    companyId,
+    employeeId,
+  } = action;
+  return {
+    ...state,
+    instance: {
+      dataStatus,
+      isOrderHandled,
+      uniqid,
+      isPaid,
+      steps,
+      companyId,
+      employeeId,
+    },
+  };
+};