@legalplace/wizardx-core 0.0.1-alpha.0

package/src/libs/PathReader.ts

@@ -0,0 +1,272 @@
+import { createMatchSelector, RouterState } from 'connected-react-router';
+import queryString from 'query-string';
+import { getConfig } from '../config';
+import { StateType } from '../types/State.type';
+import { getPluginsPageAppStates } from '../PluginLoader';
+import {
+  selectAvailableSections,
+  selectAvailableAppStates,
+} from '../redux/selectors/app';
+import Globals from '../Globals';
+
+export class PathReader {
+  currentPage = 1;
+
+  currentSectionId = 1;
+
+  currentAppState = '';
+
+  currentPermalink = '';
+
+  currentView = '';
+
+  prefix = '';
+
+  currentUniqid: string | undefined = undefined;
+
+  modelVersion: string | undefined = undefined;
+
+  constructor(state: StateType) {
+    this.matchWithUniqId(state);
+    this.matchWithoutUniqId(state);
+
+    // Setting current id from state
+    if (state.app.instance.uniqid !== '') {
+      this.currentUniqid = state.app.instance.uniqid;
+    }
+  }
+
+  /**
+   * Matches paths without uniqid
+   *
+   * @param state Redux State
+   */
+  matchWithoutUniqId(state: StateType): void {
+    type RouteType = {
+      permalink: string;
+      page: string;
+      view: string;
+      prefix: string;
+      modelVersion: string;
+    };
+    const matchSelector = createMatchSelector<
+      { router: RouterState },
+      RouteType
+    >(getConfig().router.wizardPath);
+    const match = matchSelector(state);
+
+    if (match) {
+      const { permalink, page, view, prefix } = match.params;
+      const modelVersion = queryString.parse(window.location.search).version;
+      this.prefix = prefix || '';
+      this.currentPermalink = Globals.permalink || permalink;
+      this.currentPage = this.getPageNumber(page);
+      this.currentSectionId = this.getSectionId();
+      this.currentAppState = this.getAppState(page);
+      this.currentView = view;
+      this.modelVersion =
+        typeof modelVersion === 'string' ? modelVersion : undefined;
+    }
+  }
+
+  /**
+   * Matches paths with uniqid
+   *
+   * @param state Redux State
+   */
+  matchWithUniqId(state: StateType): void {
+    type RouteType = {
+      permalink: string;
+      prefix: string;
+      page: string;
+      uniqid: string;
+      view: string;
+      modelVersion: string;
+    };
+    const matchSelector = createMatchSelector<
+      { router: RouterState },
+      RouteType
+    >(getConfig().router.wizardInstancePath);
+    const match = matchSelector(state);
+
+    if (match) {
+      const { permalink, page, uniqid, view, prefix } = match.params;
+      const modelVersion = queryString.parse(window.location.search).version;
+      this.currentPermalink = Globals.permalink || permalink;
+      this.prefix = prefix || '';
+      this.currentPage = this.getPageNumber(page);
+      this.currentSectionId = this.getSectionId();
+      this.currentUniqid = uniqid;
+      this.currentAppState = this.getAppState(page);
+      this.currentView = view;
+      this.modelVersion =
+        typeof modelVersion === 'string' ? modelVersion : undefined;
+    }
+  }
+
+  /**
+   * Returns given pages app state name
+   * @param page Page
+   */
+  getAppState(page: string) {
+    const appStatesPages = this.getAppStatesPages();
+
+    // Initiating current app State with wizard
+    // so that we always fall back to it in case
+    // we don't find the app state
+    let currentAppState = 'wizard';
+
+    // Looking for the app state
+    Object.keys(appStatesPages).forEach((appState) => {
+      if (appStatesPages[appState] === page) currentAppState = appState;
+    });
+
+    return currentAppState;
+  }
+
+  /**
+   * Recieves a page number and returns its according page name
+   * Example: email, termsheet etc...
+   * @param page
+   */
+  getPageUrlName(page: number): string {
+    const pagesArray = this.getPagination().pages;
+    if (page > pagesArray.length) return `${pagesArray[pagesArray.length - 1]}`;
+    return `${pagesArray[page - 1]}`;
+  }
+
+  /**
+   * Returns current page number from page slug
+   * @param page Page
+   */
+  getPageNumber(page: string) {
+    const { pages } = this.getPagination();
+    const parsedPage = Number.isNaN(parseInt(page, 10))
+      ? page
+      : parseInt(page, 10);
+
+    return pages.indexOf(parsedPage) + 1 || 1;
+  }
+
+  /**
+   * Returns currentSectionId
+   * @param page Page number
+   */
+  getSectionId(page: number = this.currentPage) {
+    const availableSections = selectAvailableSections();
+    const { appStates } = this.getPagination();
+    const pageIndex = page - 1;
+
+    let availableSectionsIndex = 0;
+
+    if (appStates[pageIndex] === 'wizard')
+      availableSectionsIndex = pageIndex - appStates.indexOf('wizard');
+
+    return availableSections[availableSectionsIndex];
+  }
+
+  /**
+   * Returns an array containing pages names in
+   * the correct order of pagination
+   */
+  getPagination() {
+    const availableAppStates = selectAvailableAppStates();
+
+    let pages: (string | number)[] = [];
+    let appStates: string[] = [];
+    availableAppStates.forEach((currentAppState) => {
+      if (currentAppState === 'wizard')
+        selectAvailableSections().forEach(() => {
+          pages = [...pages, pages.length + 1];
+          appStates = [...appStates, 'wizard'];
+        });
+      else if (
+        Object.prototype.hasOwnProperty.call(
+          this.getAppStatesPages(),
+          currentAppState
+        )
+      ) {
+        pages = [...pages, this.getAppStatesPages()[currentAppState]];
+        appStates = [...appStates, currentAppState];
+      } else {
+        pages = [...pages, pages.length + 1];
+        appStates = [...appStates, currentAppState];
+      }
+    });
+
+    return {
+      pages,
+      appStates,
+    };
+  }
+
+  /**
+   * Returns all liste of appStates with their
+   * corresponding page name
+   */
+  getAppStatesPages() {
+    // Default Global AppStates pages
+    const globalAppStates: Record<string, string> =
+      getConfig().router.appStatesPages || {};
+
+    // Plugins AppStates pages
+    const pluginsAppStates = getPluginsPageAppStates();
+
+    return {
+      ...globalAppStates,
+      ...pluginsAppStates,
+    };
+  }
+
+  /**
+   * Recieves page number, uniqid & modelVersion & parses the right path
+   * according to those
+   * @param page Page Number
+   * @param uniqid Document's uniqid
+   * @param modelVersion Model's version
+   */
+  parsePath(
+    page: number = this.currentPage,
+    uniqid = this.currentUniqid,
+    modelVersion = this.modelVersion
+  ): string {
+    let path =
+      uniqid === undefined
+        ? getConfig().router.wizardPath
+        : getConfig().router.wizardInstancePath;
+
+    // Replacing Permalink
+    path = path.replace(/:permalink(\(([^/]*)\))?/gi, this.currentPermalink);
+
+    // Replacing Permalink
+    if (this.prefix)
+      path = path.replace(/:prefix\?(\(([^/]*)\))?/gi, this.prefix);
+    else path = path.replace(/\/:prefix\?(\(([^/]*)\))?/gi, '');
+    // Replacing page
+    path = path.replace(/:page(\(([^/]*)\))?\??/gi, this.getPageUrlName(page));
+
+    if (uniqid !== undefined) {
+      // Replacing Uniqid
+      path = path.replace(/:uniqid(\(([^/]*)\))?/gi, uniqid);
+    }
+
+    if (modelVersion !== undefined) {
+      // Replacing Uniqid
+      path += `?version=${modelVersion}`;
+    }
+
+    // Replacing view
+    path = path.replace(/:view(\(([^/]*)\))?/gi, this.currentView);
+
+    // Adding other additionnal query params
+    const queryParams = queryString.parse(window.location.search);
+    if (queryParams.version !== undefined) delete queryParams.version;
+    const cleanQueryString = queryString.stringify(queryParams);
+    if (cleanQueryString.length > 0) {
+      path += modelVersion === undefined ? '?' : '&';
+      path += cleanQueryString;
+    }
+
+    return path;
+  }
+}

package/src/libs/SectionValidity.test.ts

@@ -0,0 +1,146 @@
+import { SectionValidity } from './SectionValidity';
+import { StateType } from '../types/State.type';
+
+const mockInputs: StateType.Inputs = {
+  options: {
+    1: [true],
+    2: [true],
+    3: [true],
+    1032: [true],
+  },
+  variables: {},
+};
+
+const mockReferences: {
+  sections: StateType.References.Sections;
+  options: StateType.References.Options;
+} = {
+  sections: {
+    main: {
+      1: {
+        id: 1,
+        label: 'Section 1 - Valid Section',
+        options: [1],
+      },
+      2: {
+        id: 2,
+        label: 'Section 2 - Unvalid Section',
+        options: [2],
+      },
+      3: {
+        id: 3,
+        label: 'Section 3 - Has inexistant child',
+        options: [1032],
+      },
+    },
+  },
+  options: {
+    1: {
+      meta: {
+        type: 'checkbox',
+        id: 1,
+        label: 'Option 1',
+        step: '*',
+      },
+      options: [],
+      variables: [1],
+    },
+    2: {
+      meta: {
+        type: 'checkbox',
+        id: 2,
+        label: 'Option 2',
+        step: '*',
+      },
+      options: [3],
+      variables: [2],
+    },
+    3: {
+      meta: {
+        type: 'checkbox',
+        id: 3,
+        label: 'Option 3',
+        step: '*',
+      },
+      options: [],
+      variables: [],
+    },
+  },
+};
+
+const mockConditions: {
+  options: StateType.Conditions.Options;
+  variables: StateType.Conditions.Variables;
+  validators: StateType.Conditions.Validators;
+} = {
+  options: {
+    1: [true],
+    2: [true],
+    3: [true],
+  },
+  variables: {
+    1: [true],
+    2: [true],
+  },
+  validators: {
+    options: {
+      1: [true],
+      2: [true],
+      3: [false],
+    },
+    variables: {
+      1: [true],
+      2: [false],
+    },
+  },
+};
+
+// ../redux/selectors/inputs.ts
+jest.mock('../redux/selectors/inputs', () => ({
+  __esModule: true,
+  selectOptionInput: (id: number) => mockInputs.options[id],
+  selectOptionInputByIndex: (id: number, index: number) =>
+    mockInputs.options[id][index],
+}));
+
+// ../redux/selectors/references.ts
+jest.mock('../redux/selectors/references', () => ({
+  __esModule: true,
+  selectSectionReference: (id: number) => mockReferences.sections.main[id],
+  selectOptionReference: (id: number) => mockReferences.options[id],
+}));
+
+// ../redux/selectors/conditions.ts
+jest.mock('../redux/selectors/conditions', () => ({
+  __esModule: true,
+  selectOptionConditionValue: (id: number, index: number) =>
+    mockConditions.options[id][index],
+  selectOptionValidatorConditionValue: (id: number, index: number) =>
+    mockConditions.validators.options[id][index],
+  selectVariableConditionValue: (id: number, index: number) =>
+    mockConditions.variables[id][index],
+  selectVariableValidatorConditionValue: (id: number, index: number) =>
+    mockConditions.validators.variables[id][index],
+}));
+
+describe('SectionValidity library test suit', () => {
+  it('Checks valid section', () => {
+    expect(new SectionValidity(1).validity).toBeTruthy();
+  });
+
+  it('Checks unvalid section', () => {
+    expect(new SectionValidity(2).validity).toBeFalsy();
+  });
+
+  it('Should throw an error if option reference does not exist', () => {
+    expect(() => new SectionValidity(3).validity).toThrowError(
+      'Option 1032 does not exist'
+    );
+  });
+
+  it('Should throw an error if section does not exist', () => {
+    expect(() => new SectionValidity(4).validity).toThrowError(
+      'Section 4 does not exist'
+    );
+  });
+});

package/src/libs/SectionValidity.ts

@@ -0,0 +1,110 @@
+import {
+  selectSectionReference,
+  selectOptionReference,
+} from '../redux/selectors/references';
+import {
+  selectOptionConditionValue,
+  selectOptionValidatorConditionValue,
+  selectVariableConditionValue,
+  selectVariableValidatorConditionValue,
+} from '../redux/selectors/conditions';
+import {
+  selectOptionInput,
+  selectOptionInputByIndex,
+} from '../redux/selectors/inputs';
+
+export class SectionValidity {
+  validity = true;
+
+  sectionId: number;
+
+  constructor(sectionId: number) {
+    this.sectionId = sectionId;
+    this.checkSection();
+  }
+
+  /**
+   * Checks if current section is valid
+   */
+  private checkSection() {
+    const sectionReference = selectSectionReference(this.sectionId);
+    if (sectionReference === undefined)
+      throw new Error(`Section ${this.sectionId} does not exist`);
+
+    // Checking options
+    sectionReference.options.forEach((optionId) => {
+      // Getting option inputs
+      const optionInputs = selectOptionInput(optionId);
+
+      optionInputs.forEach((value, index) => {
+        // No need to keep running if we find a false
+        if (this.validity === false) return;
+
+        // Checking options
+        this.checkOption(optionId, index);
+      });
+    });
+  }
+
+  /**
+   * Checks whether a given option is valid or not
+   * @param optionId Option's id
+   * @param index Option's index
+   */
+  private checkOption(optionId: number, index: number) {
+    const optionReference = selectOptionReference(optionId);
+    if (optionReference === undefined)
+      throw new Error(`Option ${optionId} does not exist`);
+
+    const optionValue = selectOptionInputByIndex(optionId, index);
+    const optionCondition = selectOptionConditionValue(optionId, index);
+
+    if (optionValue === false || optionCondition === false) return;
+
+    // Checking option validity
+    const validatorValue = selectOptionValidatorConditionValue(optionId, index);
+    const optionValidity =
+      validatorValue === true || validatorValue === undefined;
+
+    // Checking all validity
+    this.validity = this.validity && optionValidity;
+
+    // No need to keep running if we find a false
+    if (this.validity === false) return;
+
+    // Checking children
+    optionReference.options.forEach((childrenId) => {
+      this.checkOption(childrenId, index);
+    });
+
+    // Checking variables
+    optionReference.variables.forEach((variableId) => {
+      // No need to keep running if we find a false
+      if (this.validity === false) return;
+
+      this.checkVariable(variableId, index);
+    });
+  }
+
+  /**
+   * Checks whether a given variable is valid or not
+   * @param variableId Variable's id
+   * @param index Variable's index
+   */
+  private checkVariable(variableId: number, index: number) {
+    const variableCondition = selectVariableConditionValue(variableId, index);
+
+    if (variableCondition === false) return;
+
+    // Checking variable validity
+    const validatorValue = selectVariableValidatorConditionValue(
+      variableId,
+      index
+    );
+    const variableValidity =
+      validatorValue === true || validatorValue === undefined;
+
+    // Checking all validity
+    this.validity = this.validity && variableValidity;
+  }
+}