@legalplace/wizardx-core 0.0.1-alpha.0

package/src/helpers/outputsParsing.ts

@@ -0,0 +1,412 @@
+import { filterXSS } from 'xss';
+import {
+  selectVariableParents,
+  selectOptionRelations,
+  selectVariableReference,
+  selectOptionReference,
+  selectVariableRelations,
+} from '../redux/selectors/references';
+import {
+  selectVariableInput,
+  selectVariableInputByIndex,
+} from '../redux/selectors/inputs';
+import { OVC_TYPE } from '..';
+
+/**
+ * Parses number to correct french number format ("," instead of ".")
+ */
+const frenchNumber = (value: string | number) => {
+  let result = typeof value === 'number' ? value.toString() : value;
+  if (/^([0-9]+)\.([0-9]+)$/.test(result.trim()))
+    result = result.trim().replace('.', ',');
+  return result;
+};
+
+/**
+ * Returns option's related variable values
+ * @param optionId Option's id
+ * @param index Occurency index
+ * @param variables Variables ids list
+ */
+export type relVarsValsT = Record<string, string | number>;
+export type getRelatedVarsT = (
+  optionId: number,
+  index: number,
+  variables: number[]
+) => relVarsValsT;
+export const getRelatedVariablesValues: getRelatedVarsT = (
+  optionId,
+  index,
+  variables
+) => {
+  // Getting variables values
+  const variablesValues: Record<string, string> = {};
+  variables.forEach((currentVariableId) => {
+    // Getting option value
+    let value = selectVariableInput(currentVariableId);
+    const variableParents = selectVariableParents(currentVariableId);
+    if (variableParents === undefined)
+      throw new Error(
+        `Variable ${currentVariableId} parents object does not exist`
+      );
+    const rootVariableParentId = variableParents[variableParents.length - 1];
+    const rootVariableParentRelations =
+      selectOptionRelations(rootVariableParentId);
+    if (rootVariableParentRelations === undefined)
+      throw new Error(`Option ${rootVariableParentId} does not exist`);
+
+    if (typeof variableParents === 'undefined') return;
+
+    // Getting rootOption parent
+
+    // Checking if current option is related to the option that changed
+    if (
+      rootVariableParentRelations.children.options.includes(optionId) ||
+      rootVariableParentRelations.dependants.includes(optionId) ||
+      optionId === rootVariableParentId
+    )
+      value = [value[index]];
+
+    // Making sure all values are strings
+    const cleanValues = value.map((currentValue) => {
+      if (['number', 'string'].includes(typeof currentValue))
+        return frenchNumber(currentValue);
+      return '';
+    });
+
+    // Joining multiple variables if needed
+    let currentVariableValue =
+      cleanValues.length === 1 ? cleanValues[0] : cleanValues.join(', ');
+
+    // Replacing \n with <br /> tags
+    currentVariableValue = currentVariableValue.replace(/\n/g, '<br />');
+
+    // Setting variable value
+    variablesValues[currentVariableId] = currentVariableValue;
+  });
+
+  return variablesValues;
+};
+
+/**
+ * Parses content with variables
+ * @param output Raw content
+ * @param id Box id
+ * @param index Occurency Index
+ * @param variables Variables values list
+ */
+const contentParsingCache: Record<string, string> = {};
+export type parseContentT = (
+  output: string,
+  id: number,
+  index: number,
+  variables: relVarsValsT
+) => string;
+export const parseContentWithVariables: parseContentT = (
+  content,
+  id,
+  index,
+  variables
+) => {
+  const variablesKey = Object.keys(variables).map(
+    (variableId) => `${variableId}:${variables[variableId]};`
+  );
+  const cacheKey = `${id}-${index}-${content}-${variablesKey}`;
+
+  // Checking cache before sarting anything
+  if (Object.prototype.hasOwnProperty.call(contentParsingCache, cacheKey)) {
+    return contentParsingCache[cacheKey];
+  }
+
+  // Inserting values
+  let parsedContent = `${content}`;
+  Object.keys(variables).forEach((variableId) => {
+    let value: string = variables[variableId].toString();
+    if (value.trim().length === 0) {
+      value = new Array(16).join('_');
+    }
+    parsedContent = parsedContent.replace(
+      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      filterXSS(value, {
+        whiteList: {
+          a: [],
+        },
+      })
+    );
+  });
+
+  // Refreshing cache result
+  contentParsingCache[cacheKey] = parsedContent;
+
+  return contentParsingCache[cacheKey];
+};
+
+/**
+ * Parses output with variables
+ * @param output Raw output
+ * @param id Box id
+ * @param index Occurency Index
+ * @param variables Variables values list
+ * @param autonums Autonums values
+ */
+const outputParsingCache: Record<string, string> = {};
+export type autonumsType = [string, string, number, string | null][];
+export type parseOutputT = (
+  output: string,
+  id: number,
+  index: number,
+  variables: relVarsValsT,
+  autonums: autonumsType
+) => string;
+export const parseOutputWithVariables: parseOutputT = (
+  output,
+  id,
+  index,
+  variables,
+  autonums
+) => {
+  const variablesKey = Object.keys(variables).map(
+    (variableId) => `${variableId}:${variables[variableId]};`
+  );
+  const autonumsKey = autonums.map((autonum) => `${autonum[1]}:${autonum[2]};`);
+  const cacheKey = `${id}-${index}-${variablesKey}-${autonumsKey}`;
+
+  // Checking cache before sarting anything
+  if (Object.prototype.hasOwnProperty.call(outputParsingCache, cacheKey)) {
+    return outputParsingCache[cacheKey];
+  }
+
+  // Inserting values
+  let parsedOutput = `${output}`;
+  Object.keys(variables).forEach((variableId) => {
+    let value: string = variables[variableId].toString();
+    if (value.trim().length === 0) {
+      value = new Array(16).join('_');
+    }
+    parsedOutput = parsedOutput.replace(
+      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      filterXSS(value)
+    );
+  });
+
+  // Inserting page breaks
+  parsedOutput = parsedOutput.replace(
+    /\[\[PAGE_BREAK\]\]/gi,
+    '<p class="pagebreak"><!-- pagebreak --></p>'
+  );
+
+  // Cleaning BLURS
+  parsedOutput = parsedOutput.replace(/\[(E|B)_BLUR\]/gi, '');
+
+  // Removing signature tags
+  parsedOutput = parsedOutput.replace(/\[signature:([0-9]+)\]/g, '');
+
+  // Inserting autonums
+  autonums.forEach((currentAn) => {
+    if (currentAn[3] === null)
+      parsedOutput = parsedOutput.replace(
+        `[${currentAn[0]}:${currentAn[1]}]`,
+        `<span class="${currentAn[0]}">${currentAn[2]}</span>`
+      );
+    else
+      parsedOutput = parsedOutput.replace(
+        `[${currentAn[0]}:${currentAn[1]}](${currentAn[3]})`,
+        `<span class="${currentAn[0]}">${currentAn[2]}</span>`
+      );
+  });
+
+  // Refreshing cache result
+  outputParsingCache[cacheKey] = parsedOutput;
+
+  return outputParsingCache[cacheKey];
+};
+
+/**
+ * Parses variable label
+ * @param id Variable's ID
+ * @param index Variable's index
+ */
+export type parseVariableLabelT = (id: number, index: number) => string;
+export const parseVariableLabel: parseVariableLabelT = (id, index = 0) => {
+  // Getting variable reference
+  const { label, fallbackLabel } = selectVariableReference(id);
+
+  // If label has no variables, let's stop here
+  // and return it
+  if (!/\[var:([0-9]+)\]/gi.test(label)) return label;
+
+  // Extracting variables ids
+  const variablesList: number[] = [];
+  const matchs = Array.from(label.matchAll(/\[var:([0-9]+)\]/g));
+  matchs.forEach((currentMatch) => {
+    variablesList.push(parseInt(currentMatch[1], 10));
+  });
+
+  // Getting parent option
+  const parentOptionId = selectVariableRelations(id).parents[0];
+
+  // Getting related variables
+  const relatedVariables = getRelatedVariablesValues(
+    parentOptionId,
+    index,
+    variablesList
+  );
+
+  // Getting values
+  const variablesValues: Record<string, string> = {};
+
+  // Tells wether to use fallbackLabel
+  let useFallback: true | null = null;
+
+  variablesList.forEach((variableId) => {
+    const value = relatedVariables[variableId];
+    if (
+      value === undefined ||
+      value === null ||
+      (typeof value === 'string' && value.trim().length === 0)
+    ) {
+      useFallback = true;
+      return;
+    }
+    variablesValues[variableId] = value.toString();
+  });
+
+  if (useFallback === true && typeof fallbackLabel === 'string')
+    return fallbackLabel;
+
+  // Inserting values
+  let parsedLabel = `${label}`;
+  variablesList.forEach((variableId) => {
+    const value: string = variablesValues[variableId];
+    parsedLabel = parsedLabel.replace(
+      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      filterXSS(value)
+    );
+  });
+
+  return parsedLabel;
+};
+
+/**
+ * Parses option label
+ * @param id Option's ID
+ * @param index Option's index
+ */
+export type parseOptionLabelT = (id: number, index: number) => string;
+export const parseOptionLabel: parseOptionLabelT = (id, index = 0) => {
+  // Getting option's reference
+  const { label, fallbackLabel } = selectOptionReference(id).meta;
+
+  // If label has no variables, let's stop here
+  // and return it
+  if (!/\[var:([0-9]+)\]/gi.test(label)) return label;
+
+  // Extracting variables ids
+  const variablesList: number[] = [];
+  const matchs = Array.from(label.matchAll(/\[var:([0-9]+)\]/g));
+  matchs.forEach((currentMatch) => {
+    variablesList.push(parseInt(currentMatch[1], 10));
+  });
+
+  // Getting related variables
+  const relatedVariables = getRelatedVariablesValues(id, index, variablesList);
+
+  // Getting values
+  const variablesValues: Record<string, string> = {};
+
+  // Tells wether to use fallbackLabel
+  let useFallback: true | null = null;
+
+  variablesList.forEach((variableId) => {
+    const value = relatedVariables[variableId];
+    if (
+      value === undefined ||
+      value === null ||
+      (typeof value === 'string' && value.trim().length === 0)
+    ) {
+      useFallback = true;
+      return;
+    }
+    variablesValues[variableId] = value.toString();
+  });
+
+  if (useFallback === true && typeof fallbackLabel === 'string')
+    return fallbackLabel;
+
+  // Inserting values
+  let parsedLabel = `${label}`;
+  variablesList.forEach((variableId) => {
+    const value: string = variablesValues[variableId];
+    parsedLabel = parsedLabel.replace(
+      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      filterXSS(value)
+    );
+  });
+
+  return parsedLabel;
+};
+
+/**
+ * Parses raw string with variables
+ * @param text String to parse
+ */
+export type parseRawT = (
+  text: string,
+  inputs?: OVC_TYPE,
+  placeholder?: string
+) => string;
+export const parseRawWithVariables: parseRawT = (text, inputs, placeholder) => {
+  /**
+   * Variables
+   */
+
+  // Extracting list of variables
+  const tagsMatch = text.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) => inputs !== undefined || selectVariableReference(c) !== undefined
+  );
+
+  // Getting values
+  const variablesValues: Record<string, string> = {};
+  variables.forEach((variableId) => {
+    const value = inputs
+      ? inputs.variables[variableId]?.[0]
+      : selectVariableInputByIndex(variableId, 0);
+    if (
+      value === undefined ||
+      value === null ||
+      (typeof value === 'string' && value.trim().length === 0)
+    ) {
+      variablesValues[variableId] = placeholder || '';
+    } else {
+      variablesValues[variableId] = value.toString();
+    }
+  });
+
+  // Inserting values
+  let parsedText = `${text}`;
+  variables.forEach((variableId) => {
+    const value: string = variablesValues[variableId];
+    parsedText = parsedText.replace(
+      new RegExp(`\\[var:${variableId}\\]`, 'gi'),
+      filterXSS(value)
+    );
+  });
+
+  return parsedText;
+};

package/src/helpers/sendinblueHelper.ts

@@ -0,0 +1,59 @@
+import PhoneNumber from 'awesome-phonenumber';
+import Extracts from '../libs/Extracts';
+import { pardotAttributes } from '../service/pardot.service';
+
+const formatMobilePhone = (phoneNumber: string): string => {
+  const sanitizedNumber = new PhoneNumber(phoneNumber, 'FR');
+
+  return !sanitizedNumber?.getNumber()?.length || !sanitizedNumber.isMobile()
+    ? ''
+    : sanitizedNumber.getNumber();
+};
+
+export const getSIBExtract = () => {
+  let sibExtract;
+  try {
+    Extracts.extractData();
+    sibExtract = Extracts.getSibExtractedData();
+    if (sibExtract.TEL) {
+      try {
+        sibExtract.SMS = formatMobilePhone(sibExtract.TEL);
+      } catch (error) {
+        // the lib we use to format phone can throw exception
+      }
+    }
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.error('Error while extracting sendiblue data', error);
+  }
+  return sibExtract;
+};
+
+export const getSendinblueIdentifyAttributes = (
+  uniqid: string,
+  documentTitle: string,
+  nbFilledVars: number,
+  VALIDATION_Q2 = false,
+  domain = 'www.legalplace.fr'
+): Record<string, string | number | undefined | boolean | null> => {
+  // Identifying client into Sendinblue
+  const sendinblueVars: {
+    [k: string]: string | undefined | boolean | number | null;
+  } = {
+    // TODO: Client_type: lpApp.getState().contract.client_type ? 'pro' : 'ind',
+    UNIQID: uniqid,
+    AB: Math.floor(Math.random() * 2),
+    TELECHARGEMENT: `${domain}/rt/${uniqid}`,
+    DOCUMENT: documentTitle,
+    WIZZARD_FILLED_FIELDS: nbFilledVars,
+    ...getSIBExtract(),
+    ...pardotAttributes(),
+    VALIDATION_Q2,
+  };
+
+  if (localStorage && localStorage.getItem('entranceUrl')) {
+    sendinblueVars.URL_ENTREE = localStorage.getItem('entranceUrl');
+  }
+
+  return sendinblueVars;
+};

package/src/hooks/index.ts

@@ -0,0 +1 @@
+export * from './usePrevious';

package/src/hooks/usePrevious.ts

@@ -0,0 +1,9 @@
+import { useRef, useEffect } from 'react';
+
+export const usePrevious = <T>(value: T): T | undefined => {
+  const ref = useRef<T>();
+  useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+};

package/src/index.ts

@@ -0,0 +1,47 @@
+import 'react-app-polyfill/ie11';
+import 'react-app-polyfill/stable';
+import './polyfills/stringRepeat';
+import './polyfills/prepend';
+import './polyfills/objectValues';
+import App from './App';
+
+// Exporting config
+export * from './config';
+
+// Exporting PluginLoader
+export * from './PluginLoader';
+
+// Exporting ThemeLoader
+export * from './ThemeLoader';
+
+// Exporting hooks
+export * from './hooks';
+
+// Exporting helpers
+export * from './helpers';
+
+// Exporting constants
+export * from './constants';
+
+// Exporting redux (selectors, actions & store)
+export * from './redux';
+export * as reduxSelectorsList from './redux/selectors';
+
+// Exporting connectors
+export * from './componentsConnectors';
+export * as componentsConnectorsList from './componentsConnectors';
+
+// Exporting librairies
+export * from './libs';
+
+// Exporting services
+export * from './service';
+
+// Exporting Types
+export * from './types/getConnectors.type';
+export * from './componentsConnectors/connector/componentConnector';
+export * from './types/State.type';
+export * from './types';
+
+// Exporting App
+export default App;

package/src/libs/ConditionsInitiator.ts

@@ -0,0 +1,164 @@
+import { StateType } from '../types/State.type';
+
+export class ConditionsInitiator {
+  private conditions: StateType.Conditions = {
+    options: {},
+    variables: {},
+    sections: {},
+    documents: {},
+    prefillers: {},
+    validators: {
+      options: {},
+      variables: {},
+    },
+  };
+
+  private references: StateType.References;
+
+  private inputs: StateType.Inputs;
+
+  /**
+   * InitalConditions Constructor
+   * @param references References object
+   */
+  constructor(references: StateType.References, inputs: StateType.Inputs) {
+    this.references = references;
+    this.inputs = inputs;
+
+    // Initiating conditions
+    this.initOptionsConditions();
+    this.initVariablesConditions();
+    this.initDocumentsConditions();
+    this.initSectionsConditions();
+    this.initPrefilliersConditions();
+    this.initValidators();
+  }
+
+  /**
+   * Returns the related occurencies length for an option
+   */
+  private getOptionOccurencyLength(optionId: string) {
+    const { parents } = this.references.relations.options[optionId];
+    if (parents === undefined)
+      throw new Error(`Cannot find parents for option ${optionId}`);
+    const rootParent = parents[parents.length - 1] || optionId;
+    const rootReference = this.references.options[rootParent];
+    const occurenciesOptionId =
+      rootReference.meta.type === 'repeated' &&
+      rootReference.meta.repeatOption !== undefined
+        ? rootReference.meta.repeatOption
+        : rootParent;
+    const inputs = this.inputs.options[occurenciesOptionId];
+    return inputs.length;
+  }
+
+  /**
+   * Returns the related occurencies length for a variable
+   */
+  private getVariableOccurencyLength(variableId: string) {
+    const { parents } = this.references.relations.variables[variableId];
+    if (parents === undefined || parents.length === 0)
+      throw new Error(`Cannot find parents for variable ${variableId}`);
+    const rootParent = parents[parents.length - 1];
+    const rootReference = this.references.options[rootParent];
+    const occurenciesOptionId =
+      rootReference.meta.type === 'repeated' &&
+      rootReference.meta.repeatOption !== undefined
+        ? rootReference.meta.repeatOption
+        : rootParent;
+    const inputs = this.inputs.options[occurenciesOptionId];
+    return inputs.length;
+  }
+
+  /**
+   * Initiates Options conditions
+   */
+  private initOptionsConditions() {
+    Object.keys(this.references.conditions.options).forEach((optionId) => {
+      this.conditions.options[optionId] = new Array(
+        this.getOptionOccurencyLength(optionId)
+      ).fill(false);
+    });
+  }
+
+  /**
+   * Initiates Variables conditions
+   */
+  private initVariablesConditions() {
+    Object.keys(this.references.conditions.variables).forEach((variableId) => {
+      this.conditions.variables[variableId] = new Array(
+        this.getVariableOccurencyLength(variableId)
+      ).fill(false);
+    });
+  }
+
+  /**
+   * Initiates Documents conditions
+   */
+  private initDocumentsConditions() {
+    Object.keys(this.references.conditions.documents).forEach(
+      (documentName) => {
+        this.conditions.documents[documentName] = false;
+      }
+    );
+  }
+
+  /**
+   * Initiates Sections conditions
+   */
+  private initSectionsConditions() {
+    Object.keys(this.references.conditions.sections).forEach((documentName) => {
+      this.conditions.sections[documentName] = {};
+      Object.keys(this.references.conditions.sections[documentName]).forEach(
+        (sectionId) => {
+          this.conditions.sections[documentName][sectionId] = false;
+        }
+      );
+    });
+  }
+
+  /**
+   * Initiates Prefillers conditions
+   */
+  private initPrefilliersConditions() {
+    Object.keys(this.references.conditions.prefillers).forEach(
+      (prefillerId) => {
+        this.conditions.prefillers[prefillerId] = new Array(
+          this.getVariableOccurencyLength(prefillerId)
+        ).fill(
+          this.references.conditions.prefillers[prefillerId].map(() => false)
+        );
+      }
+    );
+  }
+
+  /**
+   * Initiates validators
+   */
+  private initValidators() {
+    // Initiating options validators
+    Object.keys(this.references.conditions.validators.options).forEach(
+      (optionId) => {
+        this.conditions.validators.options[optionId] = new Array(
+          this.getOptionOccurencyLength(optionId)
+        ).fill(false);
+      }
+    );
+
+    // Initiating variables validators
+    Object.keys(this.references.conditions.validators.variables).forEach(
+      (variableId) => {
+        this.conditions.validators.variables[variableId] = new Array(
+          this.getVariableOccurencyLength(variableId)
+        ).fill(false);
+      }
+    );
+  }
+
+  /**
+   * Returns resulting conditions object
+   */
+  public getConditions() {
+    return this.conditions;
+  }
+}