@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/sagas/fetchModel.ts

@@ -0,0 +1,787 @@
+import { call, put, takeLatest, select, fork, join } from 'redux-saga/effects';
+import Cookies from 'universal-cookie';
+import type { CustomizationMetaDefault } from '@legalplace/models-v3-types';
+import type { HealthCheckReport } from '@legalplace/model-healthcheck/dist/libs/HealthCheck.type';
+import { Task } from '@redux-saga/core';
+import {
+  initMetaAction,
+  initPaginationAction,
+  initInstanceAction,
+  fetchModelSucceededAction,
+  fetchModelFailedAction,
+  initCustomizationMetaAction,
+  fetchModelUnhealthyAction,
+  initCustomizationAutoDefaultAction,
+  fetchModelUserLockedAction,
+  updateAvailableAppStatesAction,
+  goPageAction,
+  fetchModelNonBlockingAction,
+  setModelUuidAction,
+} from '../actions/app';
+import { ConditionsInitiator } from '../../libs/ConditionsInitiator';
+import { initReferencesAction } from '../actions/references';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+import { initConditionsAction } from '../actions/conditions';
+import { selectSectionConditionValue } from '../selectors/conditions';
+import {
+  selectAllSectionsReferences,
+  selectOptionRelations,
+} from '../selectors/references';
+import { ActionsType } from '../../types/Actions.type';
+import { selectInstanceUniqid, isStepAvailable } from '../selectors/app';
+import { getConfig, updateConfig } from '../../config';
+import { isLevelAccessibleForUser } from '../selectors/user';
+import { PathReader } from '../../libs/PathReader';
+import { IntputsInitiator } from '../../libs/InputsInitiator';
+import { initUserAction, setUserStatusAction } from '../actions/user';
+import { OvcConverter, OvcType } from '../../libs/OvcConverter';
+import { StateType } from '../../types/State.type';
+import Globals from '../../Globals';
+import {
+  getFetchModelArguments,
+  getCreateInstanceArguments,
+  getClientConfigArguments,
+  getWizardConfigArguments,
+  getModelInformationArguments,
+} from '../../service/api.manager';
+import { loadTheme, setWizardTheme } from '../../ThemeLoader';
+import { loadPlugins } from '../../PluginLoader';
+import {
+  selectMandatoryOptionItem,
+  selectMandatoryOption,
+} from '../selectors/mandatories';
+import {
+  initMandatoryOptionAction,
+  initMandatoryVariableAction,
+} from '../actions/mandatories';
+import { enableSmartscriptAction } from '../actions/smartscript';
+import {
+  FETCH_MODEL,
+  FETCH_MODEL_PREREQUISITES,
+} from '../constants/sagas/model';
+import { fetchModelAction } from '../actions/sagas/model';
+import {
+  ClientConfigResponse,
+  WizardConfigResponse,
+  CreateInstanceResponse,
+} from '../../types/api.type';
+
+const cookies = new Cookies();
+
+const getValues = (arr1: boolean[], arr2: boolean[]) => {
+  return arr1.map((v, index) => {
+    return arr2[index] || v;
+  });
+};
+
+function* setFetchModelToNonBlocking(firstCurrentAppState?: string) {
+  yield put(
+    initPaginationAction({
+      currentPage: 1,
+      greatestPage: 1,
+      currentSectionId: 0,
+      availableSections: [],
+      currentAppState: firstCurrentAppState || 'wizard',
+      availableAppStates: ['wizard'],
+    })
+  );
+
+  const state: StateType = yield select((s) => s);
+  const pathReader = new PathReader(state);
+  yield put(goPageAction(pathReader.currentPage, false));
+
+  yield put(fetchModelNonBlockingAction());
+}
+
+function* getClientConfig(permalink: string, uniqid: string) {
+  let clientConfigResponse: ClientConfigResponse = yield call(
+    fetch,
+    ...getClientConfigArguments(permalink, uniqid)
+  );
+
+  if (clientConfigResponse === undefined) {
+    throw new Error(
+      `Unable to fetch client config, we did not receive any response`
+    );
+  }
+
+  clientConfigResponse = yield call(
+    // @ts-ignore because of saga implementation of call function
+    [clientConfigResponse, 'json']
+  );
+
+  if (clientConfigResponse.clientConfig.metadata?.apiEndpoint) {
+    updateConfig({
+      ...getConfig(),
+      apiEndpoint: clientConfigResponse.clientConfig.metadata?.apiEndpoint,
+    });
+  }
+
+  if (clientConfigResponse.clientConfig.metadata?.plugins) {
+    yield call(
+      loadPlugins,
+      clientConfigResponse.clientConfig.metadata?.plugins
+    );
+  } else yield call(loadPlugins);
+
+  // Add Auth cookie domain to config
+  updateConfig({
+    ...getConfig(),
+    authCookieDomain:
+      clientConfigResponse.clientConfig.metadata?.authCookieDomain ||
+      process.env.REACT_APP_COOKIES_ALL_SUBDOMAIN,
+  });
+
+  // TODO: Redo this part more properly
+  // Loading compactTheme if we receive url param compactTheme
+  if (/compactTheme/.test(window.location.href)) {
+    // @ts-ignore: because of saga implementation of call function
+    yield call(setWizardTheme, { name: 'compact' });
+  } else if (clientConfigResponse.clientConfig.metadata?.theme?.name) {
+    yield call(
+      setWizardTheme,
+      clientConfigResponse.clientConfig.metadata.theme
+    );
+  } else {
+    yield call(loadTheme);
+  }
+
+  /**
+   * Update appstates if API send different one
+   */
+  if (clientConfigResponse.clientConfig.metadata?.appStates?.length) {
+    yield put(
+      updateAvailableAppStatesAction(
+        clientConfigResponse.clientConfig.metadata.appStates
+      )
+    );
+  }
+  /*
+   * Getting available appstates
+   */
+  const availableAppStates =
+    clientConfigResponse.clientConfig.metadata?.appStates ||
+    getConfig().appStates;
+
+  return {
+    appStates: availableAppStates,
+    enableShadowInstance:
+      clientConfigResponse.clientConfig.metadata?.enableShadowInstance || false,
+  };
+}
+
+function* getWizardConfig(
+  permalink: string,
+  uniqidParam: string,
+  prefix: string,
+  queryParams: URLSearchParams
+) {
+  let response: WizardConfigResponse = yield call(
+    // @ts-ignore because of saga implementation of call function
+    fetch,
+    ...getWizardConfigArguments(permalink, uniqidParam, prefix, queryParams)
+  );
+  if (response === undefined) {
+    throw new Error(
+      `Unable to fetch wizard config, we did not receive any response`
+    );
+  }
+  response = yield call(
+    // @ts-ignore because of saga implementation of call function
+    [response, 'json']
+  );
+  if (response.redirect) {
+    window.onbeforeunload = null; // force redirection
+    window.location.href = `${response.redirect}${
+      response.redirectParams
+        ? `?redirectUrl=${encodeURIComponent(window.location.href)}`
+        : ''
+    }`;
+  }
+  yield put(setModelUuidAction(response.modelUuid));
+
+  return { modelUuid: response.modelUuid };
+}
+
+export interface FetchModelInformationResponse {
+  references: StateType.References;
+  meta: {
+    id: number;
+    title: string;
+    modelVersion: number;
+    productType: string;
+  };
+  customization: {
+    disableAutoDefault?: boolean | undefined;
+    meta?: CustomizationMetaDefault | undefined;
+  };
+  ovc?: OvcType;
+  smartScript: boolean;
+  status?: string;
+  report: {
+    object: HealthCheckReport;
+    raw: string;
+  };
+}
+
+function* fetchModelInformation(
+  modelUuid: string,
+  permalink: string,
+  prefix: string,
+  queryParams: URLSearchParams
+) {
+  let response: FetchModelInformationResponse = yield call(
+    // @ts-ignore because of saga implementation of call function
+    fetch,
+    ...getModelInformationArguments(modelUuid, queryParams)
+  );
+  if (response === undefined) {
+    throw new Error(
+      `Unable to fetch wizard config, we did not receive any response`
+    );
+  }
+  response = yield call(
+    // @ts-ignore because of saga implementation of call function
+    [response, 'json']
+  );
+  if (response.status === 'unhealthy') {
+    if (Globals.env === 'production') {
+      yield put(fetchModelFailedAction());
+    } else yield put(fetchModelUnhealthyAction(response.report));
+    return undefined;
+  }
+
+  // Meta
+  const meta = {
+    ...response.meta,
+    permalink,
+    prefix,
+  };
+  yield put(initMetaAction(meta));
+
+  // Setting document title
+  document.title = `${meta.title} - ${getConfig().brand?.name || 'LegalPlace'}`;
+
+  const { references, customization, smartScript } = response;
+  /**
+   * Initiating References
+   */
+  yield put(initReferencesAction(references));
+
+  /**
+   * Initiating Customizations
+   */
+
+  // Disable auto default
+  if (customization.disableAutoDefault !== undefined)
+    yield put(
+      initCustomizationAutoDefaultAction(customization.disableAutoDefault)
+    );
+
+  // Meta customizations
+  if (
+    typeof customization === 'object' &&
+    typeof customization.meta === 'object'
+  )
+    yield put(initCustomizationMetaAction(customization.meta));
+
+  return { ovc: response.ovc, references, meta: response.meta, smartScript };
+}
+
+function* fetchInstanceInformation(
+  appStates: string[],
+  permalink: string,
+  uniqid: string,
+  uniqidParam: string,
+  prefix: string,
+  queryParams: URLSearchParams,
+  pathReader: PathReader
+) {
+  // @ts-ignore because of saga implementation of call function
+  let response = yield call(
+    // @ts-ignore because of saga implementation of call function
+    fetch,
+    ...getFetchModelArguments(permalink, uniqidParam, prefix, queryParams)
+  );
+  if (response === undefined) {
+    throw new Error(
+      `Unable to fetch ${permalink}${
+        uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : ''
+      }, we did not recieve any response`
+    );
+  }
+  // @ts-ignore because of saga implementation of call function
+  response = yield call([response, 'json']);
+  if (response.redirect) {
+    window.onbeforeunload = null; // force redirection
+    window.location.href = `${response.redirect}${
+      response.redirectParams
+        ? `?redirectUrl=${encodeURIComponent(window.location.href)}`
+        : ''
+    }`;
+  }
+  if (response.errors || response.status === 'error') {
+    throw new Error(
+      `Unable to fetch ${permalink}${
+        uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : ''
+      }`
+    );
+  }
+
+  // reload to legacy wizard if instance is of legacy type
+  if (response.instance && response.instance.appType === 'react') {
+    const abCookie = cookies.get('X-Source');
+    if (abCookie && abCookie.split('/').length > 1) {
+      cookies.set('X-Source', `${abCookie.split('/')[0]}/wizard`, {
+        path: '/',
+        encode: (value: string) => value,
+      });
+      window.onbeforeunload = () => {};
+      document.location.reload();
+    }
+  }
+
+  // Instance
+  const instance: StateType.App.Instance = {
+    dataStatus: 'saved',
+    uniqid: uniqid || '',
+    draft: response.instance && response.instance.draft,
+    companyId: response.instance?.companyId,
+    employeeId: response.instance?.employeeId,
+    isOrderHandled: response.instance && response.instance.isOrderHandled,
+    isPaid:
+      response.instance &&
+      (response.instance.isPaid.toString() === '1' ||
+        response.instance.isPaid === true),
+    steps:
+      response.instance &&
+      (typeof response.instance.steps === 'string' ||
+        Array.isArray(response.instance.steps))
+        ? response.instance.steps
+        : [1],
+  };
+
+  // TODO: The following line displays all steps
+  // when we receive the version query param
+  // we're assuming it's coming from the editor
+  // and therefor display all steps for the
+  // modelisator, this is a quick solution
+  // for the problem that is not quite secure
+  // review it
+  if (pathReader.modelVersion) instance.steps = '*';
+
+  yield put(initInstanceAction(instance));
+
+  /*
+   * Getting available appstates
+   */
+  const availableAppStates = appStates || getConfig().appStates;
+  /*
+   * Initiating user
+   */
+  if (
+    typeof response.user === 'object' &&
+    typeof response.user.email === 'string' &&
+    typeof response.user.displayName === 'string' &&
+    typeof response.user.level === 'string'
+  ) {
+    yield put(
+      initUserAction({
+        email: response.user.email,
+        displayName: response.user.displayName,
+        level: response.user.level,
+      })
+    );
+    yield put(setUserStatusAction('authenticated'));
+    if (availableAppStates.includes('email'))
+      availableAppStates.splice(availableAppStates.indexOf('email'), 1);
+  }
+
+  /**
+   * If instance is locked for the user
+   */
+  if (instance.draft === false && !isLevelAccessibleForUser('USER')) {
+    yield put(fetchModelUserLockedAction());
+  }
+
+  return { instance, availableAppStates, ovc: response.ovc };
+}
+
+function* createInstance(
+  enableShadowInstance: boolean,
+  modelInformation: { meta: { modelVersion: string } },
+  uniqid: string,
+  permalink: string,
+  pathReader: PathReader,
+  urlParams: URLSearchParams
+) {
+  const { meta } = modelInformation;
+
+  /**
+   * Unit/Organization params define if we allow shadow instance, we fallback to configuration if not defined
+   */
+  const isShadowInstanceEnabled =
+    typeof enableShadowInstance !== 'undefined'
+      ? enableShadowInstance
+      : getConfig().enableShadowInstance;
+
+  // Instance
+  const instance: StateType.App.Instance = {
+    dataStatus: 'saved',
+    uniqid: uniqid || '',
+    draft: false,
+    companyId: undefined,
+    employeeId: undefined,
+    isOrderHandled: undefined,
+    isPaid: false,
+    steps: [1],
+  };
+
+  // TODO: The following line displays all steps
+  // when we receive the version query param
+  // we're assuming it's coming from the editor
+  // and therefor display all steps for the
+  // modelisator, this is a quick solution
+  // for the problem that is not quite secure
+  // review it
+  if (pathReader.modelVersion) instance.steps = '*';
+
+  // Creating instance
+  if (
+    isShadowInstanceEnabled === true &&
+    (instance.uniqid === undefined ||
+      (typeof instance.uniqid === 'string' && instance.uniqid.trim() === ''))
+  ) {
+    const searchParams = `${
+      urlParams && urlParams.get('contractName') && urlParams.get('userId')
+        ? `?contractName=${urlParams.get(
+            'contractName'
+          )}&userId=${urlParams.get('userId')}`
+        : ''
+    }`;
+    const res: CreateInstanceResponse = yield call(
+      // @ts-ignore because of saga implementation of call function
+      fetch,
+      ...getCreateInstanceArguments(permalink, searchParams, meta.modelVersion)
+    );
+    const instanceResponse: CreateInstanceResponse = yield call(
+      // @ts-ignore because of saga implementation of call function
+      [res, 'json']
+    );
+
+    if (instanceResponse.status !== 'SUCCESS') {
+      throw new Error('Unable to create instance');
+    }
+
+    // Setting uniqid
+    instance.uniqid = instanceResponse.uniqid;
+
+    // Setting isPaid
+    instance.isPaid = instanceResponse.isPaid === true;
+
+    // Setting is order handled
+    instance.isOrderHandled = instanceResponse.isOrderHandled;
+
+    // Setting steps
+    instance.steps =
+      typeof instanceResponse.steps === 'string' ||
+      Array.isArray(instanceResponse.steps)
+        ? instanceResponse.steps
+        : [1];
+  }
+
+  /**
+   * Initiating Instance
+   */
+  yield put(initInstanceAction(instance));
+}
+
+function* fetchModelPrerequisites(
+  action: ActionsType.Sagas.Model.fetchModelPrerequisites
+): any {
+  const { permalink, prefix } = action;
+
+  // TODO Fix Smartscript iFrame re-render (see issue #4130)
+  if (!permalink && window.location.href.includes('smartscript')) return;
+
+  const uniqid = selectInstanceUniqid();
+  const uniqidParam = uniqid && uniqid.trim().length > 0 ? `/${uniqid}` : '';
+  const urlParams = new URLSearchParams(window.location.search);
+
+  // Getting State
+  const state = yield select((s) => s);
+
+  // Model ID
+  const pathReader = new PathReader(state);
+  const queryParams = new URLSearchParams(window.location.search);
+  if (pathReader.modelVersion)
+    queryParams.set('version', pathReader.modelVersion);
+
+  const clientConfigTask: Task = yield fork(
+    // @ts-ignore because of saga implementation of fork function
+    getClientConfig,
+    permalink,
+    uniqid
+  );
+
+  const wizardConfigTask: Task = yield fork(
+    // @ts-ignore because of saga implementation of fork function
+    getWizardConfig,
+    permalink,
+    uniqidParam,
+    prefix,
+    queryParams
+  );
+
+  const [clientConfigReturnValue, wizardConfig] = yield join([
+    clientConfigTask,
+    wizardConfigTask,
+  ]);
+
+  yield put(
+    fetchModelAction(
+      permalink,
+      prefix,
+      uniqid,
+      uniqidParam,
+      queryParams,
+      pathReader,
+      urlParams,
+      clientConfigReturnValue,
+      wizardConfig
+    )
+  );
+}
+
+function* fetchModelDecorator(action: ActionsType.Sagas.Model.fetchModel): any {
+  try {
+    const {
+      permalink,
+      prefix,
+      uniqid,
+      uniqidParam,
+      queryParams,
+      pathReader,
+      urlParams,
+      clientConfigReturnValue,
+      wizardConfig,
+      callback,
+      firstCurrentAppState,
+    } = action;
+
+    if (callback) {
+      yield call(setFetchModelToNonBlocking, firstCurrentAppState);
+    }
+
+    // TODO checkout set the rest to asynchronous if checkout
+    const fetchModelInformationTask = yield fork(
+      // @ts-ignore because of saga implementation of fork function
+      fetchModelInformation,
+      wizardConfig.modelUuid,
+      permalink,
+      prefix,
+      queryParams
+    );
+
+    let modelInformation;
+    let ovcFromApi;
+    let availableAppStates;
+    if (uniqid) {
+      const fetchInstanceInformationTask = yield fork(
+        // @ts-ignore because of saga implementation of fork function
+        fetchInstanceInformation,
+        clientConfigReturnValue.appStates,
+        permalink,
+        uniqid,
+        uniqidParam,
+        prefix,
+        queryParams,
+        pathReader
+      );
+
+      const [modelInformationFromTask, instanceInformation] = yield join([
+        fetchModelInformationTask,
+        fetchInstanceInformationTask,
+      ]);
+      modelInformation = modelInformationFromTask;
+      ovcFromApi = instanceInformation.ovc;
+      availableAppStates = instanceInformation.availableAppStates;
+    } else {
+      modelInformation = yield join(fetchModelInformationTask);
+      ovcFromApi = modelInformation.ovc;
+      availableAppStates = clientConfigReturnValue.appStates;
+
+      yield call(
+        // @ts-ignore because of saga implementation of fork function
+        createInstance,
+        clientConfigReturnValue.enableShadowInstance,
+        modelInformation,
+        uniqid,
+        permalink,
+        pathReader,
+        urlParams
+      );
+    }
+
+    const { references, smartScript } = modelInformation;
+
+    // OVC
+    let ovc = ovcFromApi || null;
+
+    // Setting OVC to null if it's an empty object
+    if (
+      typeof ovc === 'object' &&
+      ovc !== null &&
+      Object.keys(ovc).length === 0
+    )
+      ovc = null;
+
+    if (OvcConverter.isOvc(ovc))
+      ovc = OvcConverter.convertToOptionsVariables(ovc, references);
+
+    // Data
+    const inputs = new IntputsInitiator(references, ovc).getInputs();
+
+    // Initiating Conditions
+    const conditions = new ConditionsInitiator(
+      references,
+      inputs
+    ).getConditions();
+
+    /**
+     * Initiating conditions first before initiating inputs
+     */
+    yield put(initConditionsAction(conditions));
+
+    /**
+     * Initiating inputs
+     */
+
+    // Options
+    const optionsIds = Object.keys(inputs.options);
+    for (let i = 0; i < optionsIds.length; i += 1) {
+      let optionId = parseInt(optionsIds[i], 10);
+      let values = inputs.options[optionId];
+      yield put(initOptionAction(optionId, values));
+      // If option is mandatory we initiate it
+      const { meta: meta2 } = references.options[optionId];
+      const { type } = meta2;
+      let { mandatory } = meta2;
+      let sendOptionAction = true;
+      if (['checkbox', 'radio'].includes(type)) {
+        if (type === 'radio') {
+          const { parents } = selectOptionRelations(optionId);
+          // Get parentId
+          const parentId = parents[0];
+          // check if optin exist on mandatory
+          const isMandatoryOption = selectMandatoryOptionItem(parentId);
+          // If parentId value = true don't send an action
+          if (typeof isMandatoryOption !== 'undefined') {
+            const mandatoryOption = selectMandatoryOption(parentId);
+            sendOptionAction = !mandatoryOption.every((v) => v === true);
+            // handle multiple
+            if (sendOptionAction === true && mandatoryOption) {
+              if (values.length >= mandatoryOption.length) {
+                values = getValues(values, [...mandatoryOption]);
+              } else {
+                values = getValues([...mandatoryOption], values);
+              }
+            }
+          }
+
+          mandatory = references.options[parentId].meta.mandatory;
+          optionId = parentId;
+        }
+
+        if (mandatory === true && sendOptionAction === true) {
+          yield put(initMandatoryOptionAction(optionId, values));
+        }
+      }
+    }
+
+    // Variables
+    const variablesIds = Object.keys(inputs.variables);
+    for (let i = 0; i < variablesIds.length; i += 1) {
+      const variableId = variablesIds[i];
+      const values = inputs.variables[variableId];
+      yield put(initVariableAction(parseInt(variableId, 10), values));
+
+      // If variable is mandatory we initiate it
+      if (references.variables[variableId].mandatory === true)
+        yield put(
+          initMandatoryVariableAction(
+            parseInt(variableId, 10),
+            values.map((value) => `${value}`.trim().length > 0)
+          )
+        );
+    }
+
+    /**
+     * Initiating conditions a second time after initiating inputs
+     */
+    yield put(initConditionsAction(conditions));
+
+    /**
+     * Initiating pagination
+     */
+    const sectionsReferences = selectAllSectionsReferences();
+    if (sectionsReferences === undefined)
+      throw new Error('Sections references not found');
+    const availableSections = Object.keys(sectionsReferences)
+      .filter((sectionId) => {
+        const condition =
+          selectSectionConditionValue(parseInt(sectionId, 10)) !== false;
+        const sectionReference = sectionsReferences[sectionId];
+        const sectionGrantLevel = sectionReference.grantLevel
+          ? sectionReference.grantLevel
+          : 'GUEST';
+        const grant = isLevelAccessibleForUser(sectionGrantLevel);
+        const availableStep = isStepAvailable(sectionReference.step);
+        return condition && grant && availableStep;
+      })
+      .map((c) => parseInt(c, 10));
+
+    yield put(
+      initPaginationAction({
+        currentPage: 1,
+        greatestPage: 1,
+        currentSectionId: availableSections[0],
+        availableSections,
+        currentAppState: firstCurrentAppState || 'wizard',
+        availableAppStates,
+      })
+    );
+
+    /**
+     * Enabling smart script
+     */
+    if (smartScript === true) {
+      yield put(enableSmartscriptAction());
+    }
+
+    /**
+     * Going to page in path after
+     * initiating pagination
+     */
+    const state2 = yield select((s) => s);
+    const pathReader2 = new PathReader(state2);
+    yield put(goPageAction(pathReader2.currentPage, false));
+
+    yield put(fetchModelSucceededAction());
+
+    if (callback) {
+      yield call(callback);
+    }
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    yield put(fetchModelFailedAction());
+  }
+}
+
+function* fetchModelSaga() {
+  yield takeLatest(FETCH_MODEL_PREREQUISITES, fetchModelPrerequisites);
+  yield takeLatest(FETCH_MODEL, fetchModelDecorator);
+}
+
+export default fetchModelSaga;