@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/Extracts.ts

@@ -0,0 +1,159 @@
+import type { ExtractV3 } from '@legalplace/models-v3-types';
+import { selectCustomizationMeta } from '../redux/selectors/app';
+import { selectUserEmail } from '../redux/selectors/user';
+import {
+  selectOptionInput,
+  selectVariableInput,
+} from '../redux/selectors/inputs';
+import {
+  selectOptionReference,
+  selectVariableReference,
+} from '../redux/selectors/references';
+import { EventsTracking } from './EventsTracking';
+
+export interface ExtractObject {
+  name: string;
+  value: string;
+}
+
+class Extracts {
+  private extracts: Readonly<ExtractV3[]> = [];
+
+  private slackExtracts: {
+    [k: string]: ExtractObject[];
+  } = {};
+
+  private sendinblueExtracts: { [k: string]: string } = {};
+
+  private mixpanelExtracts: { [k: string]: string } = {};
+
+  extractData() {
+    const customizationMeta = selectCustomizationMeta();
+    if (
+      !(
+        typeof customizationMeta === 'object' &&
+        Array.isArray(customizationMeta.extracts) &&
+        customizationMeta.extracts.length > 0
+      )
+    )
+      return;
+    this.extracts = customizationMeta.extracts;
+    this.prepareExtracts();
+    this.sendSlackMessages();
+    // this.sendSendinblue(); Remove SIB data sent there we send all in the identify
+    this.sendMixpanel();
+  }
+
+  getSibExtractedData() {
+    return this.sendinblueExtracts;
+  }
+
+  private prepareExtracts() {
+    this.extracts.forEach((extract) => {
+      const { id, type, destination } = extract;
+      let inputs: Readonly<string[]>;
+      let defaultName: string;
+
+      // Getting inputs
+      if (type === 'option') {
+        inputs = selectOptionInput(id).map((value) =>
+          value === true ? 'True' : 'False'
+        );
+        defaultName = selectOptionReference(id).meta.label;
+      } else if (type === 'variable') {
+        inputs = selectVariableInput(id).map((value) => value.toString());
+        defaultName = selectVariableReference(id, true).label;
+      } else {
+        throw new Error(`Unkown extract type ${type}`);
+      }
+
+      // Making sure default name is never empty
+      defaultName =
+        defaultName.trim().length > 0 ? defaultName : `${type} ${id}`;
+
+      // Joining inputs
+      const value =
+        inputs.length > 1 ? inputs.join(', ').slice(0, -2) : inputs[0];
+
+      // Slack
+      if (
+        typeof destination.slack === 'object' &&
+        typeof destination.slack.channel === 'string' &&
+        destination.slack.channel.trim().length > 0
+      ) {
+        const { name, channel } = destination.slack;
+
+        if (this.slackExtracts[channel] === undefined)
+          this.slackExtracts[channel] = [];
+
+        this.slackExtracts[channel].push({
+          name: name || defaultName,
+          value,
+        });
+      }
+
+      // Sendinblue
+      if (typeof destination.sendinblue === 'object' && value && value.trim()) {
+        const name = destination.sendinblue.name || defaultName;
+
+        this.sendinblueExtracts = {
+          ...this.sendinblueExtracts,
+          [name]: value,
+        };
+      }
+
+      // Mixpanel
+      if (typeof destination.mixpanel === 'object') {
+        const name = destination.mixpanel.name || defaultName;
+
+        this.mixpanelExtracts = {
+          ...this.mixpanelExtracts,
+          [name]: value,
+        };
+      }
+    });
+  }
+
+  private sendSlackMessages() {
+    const channels = Object.keys(this.slackExtracts);
+    channels.forEach((currentChannel) => {
+      const text = this.formatSlackMessage(currentChannel);
+      const json = {
+        username: 'WizardX Extract Bot',
+        icon_emoji: ':robot_face:',
+        channel: currentChannel,
+        attachments: [
+          {
+            text,
+          },
+        ],
+      };
+
+      // Sending Slack Message
+      fetch(
+        'https://hooks.slack.com/services/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',
+        {
+          body: JSON.stringify(json),
+          method: 'POST',
+        }
+      ).catch(async (err) => {
+        throw new Error(err);
+      });
+    });
+  }
+
+  private sendMixpanel() {
+    EventsTracking.trackMix('Variable Extraction', this.mixpanelExtracts);
+  }
+
+  private formatSlackMessage(channel: string) {
+    const lines = [`Email: ${selectUserEmail()}`];
+    this.slackExtracts[channel].forEach((extract) => {
+      const { name, value } = extract;
+      lines.push(`*${name}:* ${value}`);
+    });
+    return lines.join('\n');
+  }
+}
+
+export default new Extracts();

package/src/libs/InputsInitiator.ts

@@ -0,0 +1,136 @@
+import { StateType } from '../types/State.type';
+
+export type OVC_TYPE = {
+  options: {
+    [key: string]: boolean[];
+  };
+  variables: {
+    [key: string]: (number | string)[];
+  };
+};
+export class IntputsInitiator {
+  private inputs: StateType.Inputs = {
+    options: {},
+    variables: {},
+  };
+
+  private references: StateType.References;
+
+  private ovc: OVC_TYPE | null;
+
+  /**
+   * InitalConditions Constructor
+   * @param references References object
+   */
+  constructor(references: StateType.References, ovc: OVC_TYPE | null) {
+    this.references = references;
+    this.ovc = ovc;
+
+    // Setting multiples
+    this.setMultiples();
+
+    // Initiating inputs
+    this.initOptionsInputs();
+    this.initVariablesInputs();
+  }
+
+  public getInputs() {
+    return this.inputs;
+  }
+
+  private setMultiples() {
+    if (this.ovc === null) return;
+    Object.keys(this.ovc.options).forEach((id) => {
+      if (this.ovc === null) return;
+      const inputs = this.ovc.options[id];
+
+      if (inputs.length > 1) {
+        // Getting parents
+        const parentsTree = this.references.relations.options[id].parents;
+
+        // root parent
+        const rootOptionId =
+          parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
+
+        if (!this.ovc.options[rootOptionId]) {
+          // root Option reference
+          const rootReference = this.references.options[rootOptionId];
+          if (rootReference.meta.type === 'static') {
+            this.ovc.options[rootOptionId] = new Array(inputs.length).fill(
+              true
+            );
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Initates options inputs
+   */
+  private initOptionsInputs() {
+    // Options
+    const optionsIds = Object.keys(this.references.options);
+    for (let i = 0; i < optionsIds.length; i += 1) {
+      const optionId = optionsIds[i];
+      const option = this.references.options[optionId];
+
+      let values = [false];
+      if (
+        this.ovc &&
+        Object.prototype.hasOwnProperty.call(this.ovc.options, optionId)
+      ) {
+        if (
+          [
+            'static',
+            'hidden',
+            'brut-text',
+            'repeated',
+            'box',
+            'separator',
+          ].includes(option.meta.type)
+        ) {
+          values = new Array(this.ovc.options[optionId].length).fill(true);
+        } else {
+          values = this.ovc.options[optionId];
+        }
+      } else if (
+        [
+          'static',
+          'hidden',
+          'brut-text',
+          'repeated',
+          'box',
+          'separator',
+        ].includes(option.meta.type)
+      ) {
+        values = [true];
+      }
+
+      this.inputs.options[optionId] = values;
+    }
+  }
+
+  /**
+   * Initates variables inputs
+   */
+  private initVariablesInputs() {
+    const variablesIds = Object.keys(this.references.variables);
+    for (let i = 0; i < variablesIds.length; i += 1) {
+      const variableId = variablesIds[i];
+
+      let values: (string | number)[] = [''];
+      if (
+        this.ovc &&
+        Object.prototype.hasOwnProperty.call(this.ovc.variables, variableId)
+      ) {
+        values = this.ovc.variables[variableId];
+      } else {
+        const defaultValue = '';
+        values = [defaultValue];
+      }
+
+      this.inputs.variables[variableId] = values;
+    }
+  }
+}

package/src/libs/NumAuto.test.ts

@@ -0,0 +1,55 @@
+import { NumAuto } from './NumAuto';
+
+describe('NumAuto Test Suit', () => {
+  it('Resets properly', () => {
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+    NumAuto.resetNums();
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+    NumAuto.resetNums();
+  });
+
+  it('It increments indexes correctly', () => {
+    NumAuto.resetNums();
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+  });
+
+  it('It tags properly', () => {
+    NumAuto.resetNums();
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', 'myTestTag')).toEqual(2);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+
+    // Getting tag
+    expect(NumAuto.getNumPre('myTestTag', 0, 0)).toEqual(2);
+    expect(NumAuto.getNum('myTestTag', null)).toEqual(2);
+  });
+
+  it('It returns previous indexes correctly', () => {
+    NumAuto.resetNums();
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+
+    // NumPre
+    expect(NumAuto.getNumPre('myTestIndex', 0, 1)).toEqual(3);
+    expect(NumAuto.getNumPre('myOtherTestIndex', 0, 0)).toEqual(2);
+
+    // Incrementing again
+    expect(NumAuto.getNum('myTestIndex', null)).toEqual(4);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(3);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(4);
+    expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(5);
+
+    // NumPre
+    expect(NumAuto.getNumPre('myTestIndex', 0, 0)).toEqual(4);
+    expect(NumAuto.getNumPre('myOtherTestIndex', 0, 1)).toEqual(5);
+  });
+});

package/src/libs/NumAuto.ts

@@ -0,0 +1,56 @@
+class _NumAuto {
+  numsList: Record<string, any> = {};
+
+  tagsCatalog: Record<string, number> = {};
+
+  /**
+   * Increments the given catalog by 1 and
+   * returns the count
+   * @param catalog Catalog name
+   */
+  getNum = (catalog: string, tag: string | null): number => {
+    // In case the catalog doesn't exist
+    if (!Object.prototype.hasOwnProperty.call(this.numsList, catalog)) {
+      // Let's first make sure it's not a tag and return it if it is
+      if (Object.prototype.hasOwnProperty.call(this.tagsCatalog, catalog))
+        return this.tagsCatalog[catalog];
+
+      // Otherwise we set a new catalog
+      this.numsList[catalog] = 0;
+    }
+
+    this.numsList[catalog] += 1;
+
+    if (typeof tag === 'string') this.tagsCatalog[tag] = this.numsList[catalog];
+
+    return this.numsList[catalog];
+  };
+
+  /**
+   * Returns the current count of the given catalog
+   * @param catalog Catalog name
+   */
+  getNumPre = (
+    catalog: string,
+    index: number,
+    siblingsCount: number
+  ): number => {
+    // In case the catalog doesn't exist
+    if (!Object.prototype.hasOwnProperty.call(this.numsList, catalog)) {
+      // Let's first make sure it's not a tag and return it if it is
+      if (Object.prototype.hasOwnProperty.call(this.tagsCatalog, catalog))
+        return siblingsCount > 0
+          ? this.tagsCatalog[catalog] - (siblingsCount - (index + 1))
+          : this.tagsCatalog[catalog];
+    }
+    return siblingsCount > 0
+      ? this.numsList[catalog] - (siblingsCount - (index + 1))
+      : this.numsList[catalog];
+  };
+
+  resetNums = () => {
+    this.numsList = {};
+  };
+}
+
+export const NumAuto = new _NumAuto();

package/src/libs/OvcConverter.ts

@@ -0,0 +1,285 @@
+import { StateType } from '../types/State.type';
+import {
+  selectOptionParents,
+  selectOptionReference,
+  selectVariableParents,
+} from '../redux/selectors/references';
+import { selectOptionInput } from '../redux/selectors/inputs';
+
+export interface OvcType {
+  o: {
+    [k: string]: string | number | (string | number)[];
+  };
+  v: {
+    [k: string]: string | number | (string | number)[];
+  };
+  c: {
+    [k: string]: boolean | boolean[];
+  };
+}
+
+class _OvcConverter {
+  public convertToOptionsVariables(
+    ovc: OvcType,
+    references: StateType.References
+  ) {
+    const inputs: StateType.Inputs = {
+      options: {},
+      variables: {},
+    };
+
+    if (typeof ovc !== 'object') return inputs;
+
+    // Reading options
+    if (typeof ovc.o === 'object') {
+      Object.keys(ovc.o).forEach((id) => {
+        const currentOption = ovc.o[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentOption)) {
+          const occurences = currentOption.length;
+          // Adding static childrens
+          inputs.options = {
+            ...inputs.options,
+            ...this.pushStaticChildren(
+              inputs.options,
+              id,
+              occurences,
+              references
+            ),
+          };
+          currentOption.forEach((childId, index) => {
+            const sanitizedId =
+              typeof childId === 'string' && childId.split('_').length > 0
+                ? childId.split('_')[0]
+                : childId;
+
+            // Making sure the input exist
+            if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
+              inputs.options[id] = new Array(occurences).fill(false);
+            }
+
+            // Making sure the childId is not empty
+            if (
+              typeof sanitizedId === 'string' &&
+              sanitizedId.trim().length === 0
+            ) {
+              return;
+            }
+
+            // Creating input if it doesn't exist
+            if (
+              !Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)
+            ) {
+              inputs.options[sanitizedId] = new Array(occurences).fill(false);
+            }
+
+            // Adding static childrens
+            inputs.options = {
+              ...inputs.options,
+              ...this.pushStaticChildren(
+                inputs.options,
+                sanitizedId,
+                occurences,
+                references
+              ),
+            };
+
+            // Setting current index to true
+            inputs.options[sanitizedId][index] = true;
+          });
+        } else {
+          if (
+            typeof currentOption === 'string' &&
+            currentOption.trim().length === 0
+          )
+            return;
+          inputs.options[currentOption] = [true];
+        }
+      });
+    }
+
+    // Reading checkboxes
+    if (typeof ovc.c === 'object') {
+      Object.keys(ovc.c).forEach((id) => {
+        const currentCheckbox = ovc.c[id];
+        if (typeof id === 'string' && id.trim().length === 0) return;
+        // If it's a multiple
+        if (Array.isArray(currentCheckbox)) {
+          inputs.options[id] = currentCheckbox;
+        } else {
+          inputs.options[id] = [currentCheckbox];
+        }
+      });
+    }
+
+    // Reading variables
+    if (typeof ovc.v === 'object') {
+      Object.keys(ovc.v).forEach((id) => {
+        const currentVariable = ovc.v[id];
+
+        // If it's a multiple
+        if (Array.isArray(currentVariable)) {
+          inputs.variables[id] = currentVariable;
+          // Getting parentsTree & parent id
+          const parentsTree = references.relations.variables[id].parents;
+          const parentOption =
+            inputs.options[`${parentsTree[parentsTree.length - 1]}`];
+          if (Array.isArray(parentOption)) {
+            const occurences = parentOption.length;
+            if (currentVariable.length < occurences) {
+              inputs.variables[id] = [
+                ...currentVariable,
+                ...Array(occurences - currentVariable.length).fill(''),
+              ];
+            }
+          }
+        } else {
+          inputs.variables[id] = [currentVariable];
+        }
+      });
+    }
+
+    return inputs;
+  }
+
+  public convertToOvc(inputs: StateType.Inputs) {
+    const ovc: OvcType = {
+      o: {},
+      v: {},
+      c: {},
+    };
+
+    // Reading options
+    Object.keys(inputs.options).forEach((stringId) => {
+      const id = parseInt(stringId, 10);
+      const values = inputs.options[id];
+
+      // Getting parentsTree & parent id
+      const parentsTree = selectOptionParents(id);
+      const parentId = parentsTree[0];
+
+      // Getting references
+      const optionReference = selectOptionReference(id);
+      // Checking if it's a multiple
+      const rootOptionId =
+        parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
+      const isMultiple =
+        parentsTree.length > 0 &&
+        selectOptionReference(rootOptionId).meta.multiple?.enabled === true;
+      const occurences = selectOptionInput(rootOptionId).length;
+
+      // If it's not a radio nor a checkbox we stop here
+      if (!['radio', 'checkbox'].includes(optionReference.meta.type)) {
+        if (values.length > 1 && rootOptionId === id) {
+          ovc.o[id] = new Array(values.length).fill('');
+        }
+        return;
+      }
+
+      // Getting true indexes
+      const trueIndexes = values
+        .map((value, index) => (value === true ? index : null))
+        .filter(<T>(value: T | null): value is T => value !== null);
+
+      // Checking whether it's a radio or a checkbox
+      const isCheckbox = optionReference.meta.type === 'checkbox';
+
+      if (isCheckbox === true) {
+        if (isMultiple === true) {
+          ovc.c[id] = values;
+        } else {
+          [ovc.c[id]] = values;
+        }
+      } else if (isMultiple === true) {
+        if (!Object.prototype.hasOwnProperty.call(ovc.o, parentId)) {
+          ovc.o[parentId] = new Array(occurences).fill('');
+        }
+        trueIndexes.forEach((index) => {
+          const currentOption = ovc.o[parentId];
+          if (Array.isArray(currentOption)) {
+            currentOption[index] = id;
+          }
+        });
+      } else if (values[0] === true) {
+        ovc.o[parentId] = id;
+      }
+    });
+
+    // Reading variables
+    Object.keys(inputs.variables).forEach((stringId) => {
+      const id = parseInt(stringId, 10);
+      const values = inputs.variables[id];
+
+      // Getting parentsTree & parent id
+      const parentsTree = selectVariableParents(id);
+
+      // Checking if it's a multiple
+      const isMultiple =
+        selectOptionReference(parentsTree[parentsTree.length - 1]).meta.multiple
+          ?.enabled === true;
+      const occurences = selectOptionInput(
+        parentsTree[parentsTree.length - 1]
+      ).length;
+
+      if (isMultiple === true) {
+        if (!Object.prototype.hasOwnProperty.call(ovc.o, id)) {
+          ovc.v[id] = new Array(occurences).fill('');
+        }
+        ovc.v[id] = values;
+      } else {
+        [ovc.v[id]] = values;
+      }
+    });
+
+    return ovc;
+  }
+
+  public isOvc(_obj: StateType.Inputs | OvcType) {
+    if (typeof _obj !== 'object' || _obj === null) return false;
+    const ovcKeys = ['o', 'v', 'c'];
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (ovcKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0);
+
+    return foundKeys > 1;
+  }
+
+  public isOptionsVariables(_obj: StateType.Inputs | OvcType) {
+    if (typeof _obj !== 'object' || _obj === null) return false;
+    const optionsVariablesKeys = ['options', 'variables'];
+    const foundKeys = Object.keys(_obj)
+      .map((key): number => (optionsVariablesKeys.includes(key) ? 1 : 0))
+      .reduce((a, b) => a + b, 0);
+    return foundKeys === 2;
+  }
+
+  private pushStaticChildren(
+    inputOptions: StateType.Inputs['options'],
+    id: number | string,
+    occurences: number,
+    references: StateType.References
+  ) {
+    const result = { ...inputOptions };
+    const intId = typeof id === 'number' ? id : parseInt(id, 10);
+
+    // Getting children options and variables
+    const { options } = references.relations.options[intId].children;
+
+    // Getting static children
+    const staticOptions = options.filter((childId) => {
+      return references.options[childId].meta.type === 'static';
+    });
+
+    staticOptions.forEach((childId) => {
+      // Creating input if it doesn't exist
+      if (!Object.prototype.hasOwnProperty.call(result, childId)) {
+        result[childId] = new Array(occurences).fill(false);
+      }
+    });
+
+    return result;
+  }
+}
+
+export const OvcConverter = new _OvcConverter();