@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/sagas/homogeneousRadioInputsSaga.ts

@@ -0,0 +1,42 @@
+import { put, takeLatest } from 'redux-saga/effects';
+import { UPDATE_OPTION_INPUT } from '../constants/inputs';
+import { ActionsType } from '../../types/Actions.type';
+import { selectRadioSiblings } from '../selectors/references';
+import { updateOptionAction } from '../actions/inputs';
+import { selectOptionInputByIndex } from '../selectors/inputs';
+
+/**
+ * This Saga helps make sure radio inputs are homogenous,
+ * when a radio is set to true, this saga makes sure all
+ * its siblings are false
+ * @param action UPDATE_OPTION_INPUT Action
+ */
+function* homogeneousRadioInputsDecorator(
+  action: ActionsType.Inputs.updateOptionInput
+) {
+  // Getting option siblings
+  const { id, index, value } = action;
+
+  if (value === true) {
+    /**
+     * In case the option we are asked to update
+     * is a radio, and we need to set it to true
+     * we need to make sure all its siblings are
+     * set to false
+     */
+    const radioSiblings = selectRadioSiblings(id);
+    if (radioSiblings && value === true) {
+      for (let i = 0; i < radioSiblings.length; i += 1) {
+        const siblingId = radioSiblings[i];
+        if (selectOptionInputByIndex(siblingId, index) === true)
+          yield put(updateOptionAction(siblingId, false, index));
+      }
+    }
+  }
+}
+
+function* homogeneousRadioInputsSaga() {
+  yield takeLatest(UPDATE_OPTION_INPUT, homogeneousRadioInputsDecorator);
+}
+
+export default homogeneousRadioInputsSaga;

package/src/redux/sagas/runner.test.ts

@@ -0,0 +1,12 @@
+import { sagasRunner } from './runner';
+
+describe('Runner', () => {
+  it('Runs sagas', () => {
+    // @ts-ignore: Ignoring for mock
+    const SagaMiddleware: SagaMiddleware = {
+      run: jest.fn(),
+    };
+    sagasRunner(SagaMiddleware);
+    expect(SagaMiddleware.run).toHaveBeenCalled();
+  });
+});

package/src/redux/sagas/runner.ts

@@ -0,0 +1,24 @@
+import { SagaMiddleware } from '@redux-saga/core';
+import fetchModelSaga from './fetchModel';
+import setDefaultsSaga from './setDefaults';
+import saveDataSaga from './saveData';
+import homogeneousRadioInputsSaga from './homogeneousRadioInputsSaga';
+import setUserEmailSaga from './setUserEmail';
+
+const sagas: { (): any }[] = [
+  fetchModelSaga,
+  setDefaultsSaga,
+  saveDataSaga,
+  setUserEmailSaga,
+  homogeneousRadioInputsSaga,
+];
+
+/**
+ *
+ * @param sagaMiddleware Saga's middleware
+ */
+export const sagasRunner = (
+  sagaMiddleware: SagaMiddleware<Record<string, unknown>>
+) => {
+  sagas.forEach((saga) => sagaMiddleware.run(saga));
+};

package/src/redux/sagas/saveData.test.ts

@@ -0,0 +1,125 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import {
+  initMetaAction,
+  initPaginationAction,
+  initInstanceAction,
+} from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import {
+  initOptionAction,
+  initVariableAction,
+  updateOptionAction,
+} from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+import { saveDataAction } from '../actions/sagas/data';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require('jest-fetch-mock').enableMocks();
+
+const permalink = 'test-model';
+const uniqid = 'myMockUniqid';
+const mockApiEndpoint = 'https://api.mock/api/v1/';
+
+// Mocking config
+jest.mock('../../config', () => ({
+  getConfig: () => ({
+    apiEndpoint: mockApiEndpoint,
+  }),
+}));
+
+describe('Save data saga', () => {
+  let store: any;
+  beforeEach(() => {
+    createAppStore('memory');
+    store = getStore();
+    store.dispatch({
+      type: 'SET_DEFAULTS',
+    });
+
+    // Initiating references
+    const model = JSON.parse(
+      fs.readFileSync(
+        './src/misc/test_models/setDefaults.testmodel.json',
+        'utf8'
+      )
+    );
+    const references = new ReferencesParser(model).getReferences();
+    store.dispatch(initReferencesAction(references));
+
+    // Inputs initiation
+    const inputs = new IntputsInitiator(references, null).getInputs();
+    Object.keys(inputs.options).forEach((optionId) => {
+      const values = inputs.options[optionId];
+      store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+    });
+    Object.keys(inputs.variables).forEach((variableId) => {
+      const values = inputs.variables[variableId];
+      store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+    });
+
+    // Initiating Meta
+    store.dispatch(
+      initMetaAction({
+        id: 123,
+        title: 'Test model',
+        permalink,
+        modelVersion: 1,
+        prefix: '',
+        productType: 'demarche',
+      })
+    );
+
+    // Initiating Meta
+    store.dispatch(
+      initInstanceAction({
+        uniqid,
+        isPaid: false,
+        dataStatus: 'unsaved',
+        steps: '*',
+      })
+    );
+
+    // Initiating Pagination
+    store.dispatch(
+      initPaginationAction({
+        availableAppStates: ['wizard', 'termsheet'],
+        currentAppState: 'wizard',
+        currentPage: 4,
+        greatestPage: 4,
+        currentSectionId: 1,
+        availableSections: [1, 3],
+      })
+    );
+
+    // Initiating conditions
+    const conditions = new ConditionsInitiator(
+      references,
+      inputs
+    ).getConditions();
+    store.dispatch(initConditionsAction(conditions));
+
+    // Setting defaults
+    store.dispatch({ type: 'SET_DEFAULTS' });
+
+    // Making some more updates in the inputs
+    store.dispatch(updateOptionAction(15, true, 0));
+
+    // Resetting fetch mocks
+    fetchMock.resetMocks();
+  });
+
+  it('Sends save request to API', () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ status: 'success' }));
+
+    store.dispatch(saveDataAction());
+
+    expect(fetchMock.mock.calls.length).toEqual(1);
+    expect(fetchMock.mock.calls[0][0]).toEqual(
+      `${mockApiEndpoint}wizard/instance/${permalink}/${uniqid}`
+    );
+  });
+});

package/src/redux/sagas/saveData.ts

@@ -0,0 +1,112 @@
+import { call, put, takeLatest } from 'redux-saga/effects';
+import { v4 as uuid } from 'uuid';
+import { setDataStatus } from '../actions/app';
+import {
+  selectPermalink,
+  selectInstanceUniqid,
+  selectDocumentTitle,
+  selectInstanceIsPaid,
+} from '../selectors/app';
+import { SAVE_DATA } from '../constants/sagas/data';
+import { selectInputs } from '../selectors/inputs';
+import { OvcConverter } from '../../libs/OvcConverter';
+import { ActionsType } from '../../types/Actions.type';
+import { updateInstanceArguments } from '../../service/api.manager';
+import { getSendinblueIdentifyAttributes } from '../../helpers/sendinblueHelper';
+import { getConfig } from '../../config';
+import { selectUserEmail } from '../selectors/user';
+
+const getSendinblueData = (uniqid: string, paid: boolean) => {
+  const email = selectUserEmail();
+  const apiEndpoint =
+    getConfig().apiEndpoint + (/\/$/.test(getConfig().apiEndpoint) ? '' : '/');
+
+  // Getting OVC
+  const ovc = OvcConverter.convertToOvc(selectInputs());
+
+  // Counting filled variables
+  const nbFilledVars = Object.keys(ovc.v).reduce((p, c) => {
+    const currentValue = ovc.v[c];
+    // eslint-disable-next-line no-nested-ternary
+    const o: number = Array.isArray(currentValue)
+      ? currentValue.reduce((_p: number, _c) => _p + (_c !== '' ? 1 : 0), 0)
+      : currentValue !== ''
+      ? 1
+      : 0;
+    return p + o;
+  }, 0);
+  // if (typeof window.sendinblue !== 'undefined' && response.user) {
+  const attributes = getSendinblueIdentifyAttributes(
+    uniqid as string,
+    selectDocumentTitle(),
+    nbFilledVars,
+    paid,
+    window.location.host
+  );
+  return [apiEndpoint, email, attributes];
+};
+function* saveDataDecorator(action: ActionsType.Sagas.Data.saveData) {
+  try {
+    // eslint-disable-next-line no-console
+    yield put(setDataStatus('saving'));
+    const permalink = selectPermalink();
+    const uniqid = selectInstanceUniqid();
+    // @ts-ignore because of saga implementation
+    const response = yield call(
+      // @ts-ignore because of saga implementation
+      fetch,
+      ...updateInstanceArguments(
+        permalink,
+        uniqid,
+        OvcConverter.convertToOvc(selectInputs()),
+        action.confirmAnswer ? 0 : 1,
+        action.additionalProperties
+      )
+    );
+    // @ts-ignore because of saga implementation
+    const responseData = yield call([response, 'json']);
+    // Redirecting if we recieved order to
+    if (action.redirect === true) {
+      if (responseData.redirect_to) {
+        try {
+          // Get Data to send to sendinblue
+          const [apiEndpoint, email, attributes] = getSendinblueData(
+            uniqid as string,
+            selectInstanceIsPaid()
+          );
+          yield call(fetch, `${apiEndpoint}event/create/${uniqid}/${uuid()}`, {
+            method: 'POST',
+            credentials: 'include',
+            headers: {
+              'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+              email,
+              attributes,
+            }),
+          });
+        } catch (error) {
+          // keep going in case the request fail for now
+        }
+
+        window.onbeforeunload = () => {};
+        window.location.href = responseData.redirect_to;
+      } else if (action.redirectFallback) {
+        window.onbeforeunload = () => {};
+        window.location.href = action.redirectFallback;
+      }
+    }
+
+    yield put(setDataStatus('saved'));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    yield put(setDataStatus('failed'));
+  }
+}
+
+function* saveDataSaga() {
+  yield takeLatest(SAVE_DATA, saveDataDecorator);
+}
+
+export default saveDataSaga;

package/src/redux/sagas/setDefaults.test.ts

@@ -0,0 +1,100 @@
+import * as fs from 'fs';
+import { ReferencesParser } from '@legalplace/referencesparser';
+import { createAppStore, getStore } from '../store';
+import { initMetaAction, initPaginationAction } from '../actions/app';
+import { initReferencesAction } from '../actions/references';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+
+describe('Set defaults saga', () => {
+  let store: any;
+  beforeEach(() => {
+    createAppStore('memory');
+    store = getStore();
+    store.dispatch({
+      type: 'SET_DEFAULTS',
+    });
+
+    // Initiating references
+    const model = JSON.parse(
+      fs.readFileSync(
+        './src/misc/test_models/setDefaults.testmodel.json',
+        'utf8'
+      )
+    );
+    const references = new ReferencesParser(model).getReferences();
+    store.dispatch(initReferencesAction(references));
+
+    // Inputs initiation
+    const inputs = new IntputsInitiator(references, null).getInputs();
+    Object.keys(inputs.options).forEach((optionId) => {
+      const values = inputs.options[optionId];
+      store.dispatch(initOptionAction(parseInt(optionId, 10), values));
+    });
+    Object.keys(inputs.variables).forEach((variableId) => {
+      const values = inputs.variables[variableId];
+      store.dispatch(initVariableAction(parseInt(variableId, 10), values));
+    });
+
+    // Initiating Meta
+    store.dispatch(
+      initMetaAction({
+        id: 123,
+        title: 'Test model',
+        permalink: 'test-model',
+        prefix: '',
+        modelVersion: 1,
+        productType: 'demarche',
+      })
+    );
+
+    // Initiating Pagination
+    store.dispatch(
+      initPaginationAction({
+        availableAppStates: ['wizard', 'termsheet'],
+        currentAppState: 'wizard',
+        currentPage: 4,
+        greatestPage: 4,
+        currentSectionId: 1,
+        availableSections: [1, 3],
+      })
+    );
+
+    // Initiating conditions
+    const conditions = new ConditionsInitiator(
+      references,
+      inputs
+    ).getConditions();
+    store.dispatch(initConditionsAction(conditions));
+  });
+
+  it('Sets defaults properly', () => {
+    // Setting defaults
+    store.dispatch({ type: 'SET_DEFAULTS' });
+
+    expect(store.getState().app.wizard.availableSections).toStrictEqual([
+      1, 2, 3,
+    ]);
+
+    expect(store.getState().inputs.options).toStrictEqual({
+      1: [true],
+      2: [true],
+      3: [false],
+      4: [true],
+      5: [true],
+      6: [true],
+      7: [true],
+      8: [true],
+      9: [true],
+      10: [true],
+      11: [false],
+      12: [true],
+      13: [false],
+      14: [true],
+      15: [false],
+      16: [false],
+    });
+  });
+});

package/src/redux/sagas/setDefaults.ts

@@ -0,0 +1,167 @@
+import { call, put, takeLatest } from 'redux-saga/effects';
+import {
+  selectCurrentPage,
+  selectAvailableSections,
+  selectCurrentSectionId,
+} from '../selectors/app';
+import {
+  selectSectionDefaults,
+  selectRadioSiblings,
+} from '../selectors/references';
+import {
+  selectOptionInput,
+  selectOptionInputByIndex,
+} from '../selectors/inputs';
+import { updateOptionAction } from '../actions/inputs';
+import { goPageAction } from '../actions/app';
+import { selectOptionConditionValue } from '../selectors/conditions';
+
+function setOptionsDefaults(
+  id: number,
+  defaults: any,
+  parentIndexes?: number[]
+): any {
+  let ActionsToDispatch: any = [];
+
+  // Getting current condition
+  const currentConditions = selectOptionConditionValue(id);
+
+  // Getting current values
+  const currentValues = selectOptionInput(id);
+
+  // Getting indexes to execute defaults on if we recieved no parent indexes
+  const Indexes: number[] = parentIndexes === undefined ? [] : parentIndexes;
+  if (parentIndexes === undefined) {
+    if (currentConditions !== undefined) {
+      currentConditions.forEach((value, index) => {
+        if (value === true) Indexes.push(index);
+      });
+    } else {
+      currentValues.forEach((value, index) => {
+        if (value === true) Indexes.push(index);
+      });
+    }
+  }
+
+  // Getting current value
+  const defaultValue = defaults.isDefault ? defaults.isDefault : false;
+
+  // If it neither a default value, nor it's true, we stop here
+  if (
+    currentValues.reduce((p: boolean, c: boolean) => p && c, true) !== true &&
+    defaultValue !== true
+  )
+    return [];
+
+  // Getting options radio sibling
+  const siblings = selectRadioSiblings(id);
+
+  // Looping through indexes
+  Indexes.forEach((occurencyIndex: number) => {
+    const currentValueOccurency = currentValues[occurencyIndex];
+    // If current occurency is true we stop here
+    if (currentValueOccurency === true || defaultValue === false) return;
+
+    // Determining whether one of its radio siblings is already true
+    let siblingsValue = false;
+    if (Array.isArray(siblings) && siblings.length > 0) {
+      siblings.forEach((siblingId) => {
+        const indexValue = selectOptionInputByIndex(siblingId, occurencyIndex);
+        siblingsValue =
+          siblingsValue || (indexValue === undefined ? false : indexValue);
+      });
+    }
+
+    // If defaultValue is true and none of it's siblings are, it's
+    // safe to set it to true
+    if (!siblingsValue) {
+      ActionsToDispatch.push([id, defaultValue, occurencyIndex]);
+    }
+  });
+
+  // Going through children
+  Object.keys(defaults.children).forEach((childId) => {
+    ActionsToDispatch = [
+      ...ActionsToDispatch,
+      ...setOptionsDefaults(
+        parseInt(childId, 10),
+        defaults.children[childId],
+        Indexes
+      ),
+    ];
+  });
+
+  return ActionsToDispatch;
+}
+
+function* setDefaultOptionsSection(id: number) {
+  let ActionsToDispatch: [number, boolean, number][] = [];
+  // Getting section's defaults
+  const sectionDefaults = selectSectionDefaults(id);
+  if (sectionDefaults === undefined) return [];
+
+  Object.keys(sectionDefaults).forEach((optionId) => {
+    ActionsToDispatch = [
+      ...ActionsToDispatch,
+      ...setOptionsDefaults(parseInt(optionId, 10), sectionDefaults[optionId]),
+    ];
+  });
+
+  // Setting default options
+  for (let i = 0; i < ActionsToDispatch.length; i += 1) {
+    yield put(updateOptionAction(...ActionsToDispatch[i]));
+  }
+
+  return ActionsToDispatch;
+}
+
+function* setDefaultOptions() {
+  let ActionsToDispatch: [number, boolean, number][] = [];
+  // Getting current page & available sections list
+  const currentPage = selectCurrentPage();
+  const availableSections = selectAvailableSections();
+
+  // Getting sections
+  let sections = [...availableSections].splice(0, currentPage - 1);
+
+  // Getting previous availableSections
+  const previousAvailableSections = selectAvailableSections();
+  const previousSectionIndex = previousAvailableSections.indexOf(
+    selectCurrentSectionId()
+  );
+
+  // Going through sections
+  for (let i = 0; i < sections.length; i += 1) {
+    const sectionId = sections[i];
+    // @ts-ignore: because of saga implementation of call function
+    const actions = yield call(setDefaultOptionsSection, [sectionId]);
+
+    // If available sections changed, we update the sections array
+    sections = [...selectAvailableSections()].splice(0, currentPage - 1);
+    ActionsToDispatch = [...ActionsToDispatch, ...actions];
+  }
+  // Getting current availableSections
+  const currentAvailableSections = selectAvailableSections();
+  const currentSectionIndex = currentAvailableSections.indexOf(
+    selectCurrentSectionId()
+  );
+
+  if (
+    selectAvailableSections().length <= currentSectionIndex &&
+    currentSectionIndex !== previousSectionIndex
+  ) {
+    let newPage = currentPage;
+    if (currentSectionIndex > previousSectionIndex) {
+      newPage += currentSectionIndex - previousSectionIndex;
+    } else {
+      newPage -= previousSectionIndex - currentSectionIndex;
+    }
+    yield put(goPageAction(newPage));
+  }
+}
+
+function* setDefaultsSaga() {
+  yield takeLatest('SET_DEFAULTS', setDefaultOptions);
+}
+
+export default setDefaultsSaga;