@legalplace/wizardx-core 0.0.1-alpha.0

package/src/redux/reducers/app/instance/setDataStatus.ts

@@ -0,0 +1,16 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const setDataStatusReducer = (
+  state: StateType.App,
+  action: ActionsType.App.setDataStatus
+): StateType.App => {
+  const { dataStatus } = action;
+  return {
+    ...state,
+    instance: {
+      ...state.instance,
+      dataStatus,
+    },
+  };
+};

package/src/redux/reducers/app/instance/updateInstance.ts

@@ -0,0 +1,30 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const updateInstanceReducer = (
+  state: StateType.App,
+  action: ActionsType.App.updateInstance
+): StateType.App => {
+  const {
+    uniqid,
+    isPaid,
+    dataStatus,
+    steps,
+    isOrderHandled,
+    companyId,
+    employeeId,
+  } = action;
+  return {
+    ...state,
+    instance: {
+      ...state.instance,
+      dataStatus: dataStatus || state.instance.dataStatus,
+      isOrderHandled,
+      uniqid: uniqid || state.instance.uniqid,
+      isPaid,
+      steps: steps || state.instance.steps,
+      companyId,
+      employeeId,
+    },
+  };
+};

package/src/redux/reducers/app/instance/updateInstancePaid.ts

@@ -0,0 +1,20 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const updateInstancePaidReducer = (
+  state: StateType.App,
+  action: ActionsType.App.updateInstancePaid
+): StateType.App => {
+  const { isPaid } = action;
+
+  // Making sure value has changed before changing the state
+  if (state.instance.isPaid === isPaid) return state;
+
+  return {
+    ...state,
+    instance: {
+      ...state.instance,
+      isPaid,
+    },
+  };
+};

package/src/redux/reducers/app/instance.test.ts

@@ -0,0 +1,106 @@
+import { initInstanceReducer } from './instance/initInstance';
+import { updateInstancePaidReducer } from './instance/updateInstancePaid';
+import { StateType } from '../../../types/State.type';
+import { setDataStatusReducer } from './instance/setDataStatus';
+
+const appStateMock: StateType.App = {
+  meta: {
+    fetchStatus: 'succeeded',
+    id: 0,
+    prefix: '',
+    permalink: 'permalink',
+    title: 'title',
+    modelVersion: 1,
+    productType: 'demarche',
+  },
+  wizard: {
+    availableSections: [1, 2, 3],
+    currentSectionId: 1,
+  },
+  pagination: {
+    currentPage: 1,
+    greatestPage: 1,
+    currentAppState: 'wizard',
+    availableAppStates: ['wizard'],
+    isFirstPage: true,
+    isLastPage: false,
+    totalPages: 4,
+  },
+  instance: {
+    dataStatus: 'saved',
+    uniqid: '3jHD42343sDE',
+    isOrderHandled: undefined,
+    isPaid: false,
+    steps: '*',
+  },
+  customization: {},
+};
+
+describe('App Instance Reducer', () => {
+  // init instance reducer
+  it('initInstance Reducer', () => {
+    const reducer = initInstanceReducer(appStateMock, {
+      type: 'INIT_INSTANCE',
+      dataStatus: 'saved',
+      uniqid: '3jHD42343sDE',
+      isPaid: true,
+      steps: '*',
+    });
+
+    return expect(reducer).toStrictEqual({
+      ...appStateMock,
+      instance: {
+        dataStatus: 'saved',
+        uniqid: '3jHD42343sDE',
+        isOrderHandled: undefined,
+        companyId: undefined,
+        employeeId: undefined,
+        isPaid: true,
+        steps: '*',
+      },
+    });
+  });
+
+  // update isPaid reducer
+  it('updateInstancePaid Reducer', () => {
+    const reducer = updateInstancePaidReducer(appStateMock, {
+      type: 'UPDATE_INSTANCE_PAID',
+      isPaid: false,
+    });
+
+    expect(reducer).toEqual(appStateMock);
+  });
+
+  // update isPaid reducer
+  it('updateInstancePaid Reducer should not change state if isPaid did not change', () => {
+    const reducer = updateInstancePaidReducer(appStateMock, {
+      type: 'UPDATE_INSTANCE_PAID',
+      isPaid: true,
+    });
+
+    expect(reducer).toStrictEqual({
+      ...appStateMock,
+      instance: {
+        ...appStateMock.instance,
+        uniqid: '3jHD42343sDE',
+        isPaid: true,
+      },
+    });
+  });
+
+  // update isPaid reducer
+  it('setDataStatus Reducer', () => {
+    const reducer = setDataStatusReducer(appStateMock, {
+      type: 'SET_DATA_STATUS',
+      dataStatus: 'unsaved',
+    });
+
+    return expect(reducer).toStrictEqual({
+      ...appStateMock,
+      instance: {
+        ...appStateMock.instance,
+        dataStatus: 'unsaved',
+      },
+    });
+  });
+});

package/src/redux/reducers/app/meta/fetchModelFailed.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../../types/State.type';
+
+export const fetchModelFailedReducer = (
+  state: StateType.App
+): StateType.App => {
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      fetchStatus: 'failed',
+    },
+  };
+};

package/src/redux/reducers/app/meta/fetchModelNonBlocking.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../../types/State.type';
+
+export const fetchModelNonBlockingReducer = (
+  state: StateType.App
+): StateType.App => {
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      fetchStatus: 'nonBlocking',
+    },
+  };
+};

package/src/redux/reducers/app/meta/fetchModelSucceeded.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../../types/State.type';
+
+export const fetchModelSucceededReducer = (
+  state: StateType.App
+): StateType.App => {
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      fetchStatus: 'succeeded',
+    },
+  };
+};

package/src/redux/reducers/app/meta/fetchModelUnhealthy.ts

@@ -0,0 +1,18 @@
+import { StateType } from '../../../../types/State.type';
+import { ActionsType } from '../../../../types/Actions.type';
+
+export const fetchModelUnhealthyReducer = (
+  state: StateType.App,
+  action: ActionsType.App.fetchModelUnhealthy
+): StateType.App => {
+  const { report } = action;
+
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      fetchStatus: 'unhealthy',
+      report,
+    },
+  };
+};

package/src/redux/reducers/app/meta/fetchModelUserLocked.ts

@@ -0,0 +1,13 @@
+import { StateType } from '../../../../types/State.type';
+
+export const fetchModelUserLockedReducer = (
+  state: StateType.App
+): StateType.App => {
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      fetchStatus: 'userLocked',
+    },
+  };
+};

package/src/redux/reducers/app/meta/initMeta.ts

@@ -0,0 +1,22 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const initMetaReducer = (
+  state: StateType.App,
+  action: ActionsType.App.initMeta
+): StateType.App => {
+  const { id, permalink, title, modelVersion, productType, prefix } = action;
+
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      id,
+      prefix,
+      permalink,
+      title,
+      modelVersion,
+      productType,
+    },
+  };
+};

package/src/redux/reducers/app/meta/setModelUuid.ts

@@ -0,0 +1,17 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const setModelUuidReducer = (
+  state: StateType.App,
+  action: ActionsType.App.setModelUuid
+): StateType.App => {
+  const { modelUuid } = action;
+
+  return {
+    ...state,
+    meta: {
+      ...state.meta,
+      modelUuid,
+    },
+  };
+};

package/src/redux/reducers/app/meta.test.ts

@@ -0,0 +1,90 @@
+import { initMetaReducer } from './meta/initMeta';
+import { StateType } from '../../../types/State.type';
+import { fetchModelSucceededReducer } from './meta/fetchModelSucceeded';
+import { fetchModelFailedReducer } from './meta/fetchModelFailed';
+
+const appStateMock: StateType.App = {
+  meta: {
+    fetchStatus: 'succeeded',
+    id: 0,
+    prefix: '',
+    permalink: 'permalink',
+    title: 'title',
+    modelVersion: 1,
+    productType: 'demarche',
+  },
+  wizard: {
+    availableSections: [1, 2, 3],
+    currentSectionId: 1,
+  },
+  pagination: {
+    currentPage: 1,
+    greatestPage: 1,
+    currentAppState: 'wizard',
+    availableAppStates: ['wizard'],
+    isFirstPage: true,
+    isLastPage: false,
+    totalPages: 4,
+  },
+  instance: {
+    dataStatus: 'saved',
+    uniqid: '3jHD42343sDE',
+    isPaid: false,
+    steps: '*',
+  },
+  customization: {},
+};
+
+describe('App Meta Reducer', () => {
+  // init meta reducer
+  it('initMeta Reducer', () => {
+    const reducer = initMetaReducer(appStateMock, {
+      type: 'INIT_META',
+      id: 123,
+      prefix: '',
+      permalink: 'permalink',
+      title: 'title',
+      modelVersion: 1,
+      productType: 'demarche',
+    });
+
+    return expect(reducer).toStrictEqual({
+      ...appStateMock,
+      meta: {
+        fetchStatus: 'succeeded',
+        id: 123,
+        prefix: '',
+        permalink: 'permalink',
+        title: 'title',
+        modelVersion: 1,
+        productType: 'demarche',
+      },
+    });
+  });
+
+  // fetchModelSucceeded reducer
+  it('fetchModelSucceeded Reducer', () => {
+    const reducer = fetchModelSucceededReducer(appStateMock);
+
+    return expect(reducer).toStrictEqual({
+      ...appStateMock,
+      meta: {
+        ...appStateMock.meta,
+        fetchStatus: 'succeeded',
+      },
+    });
+  });
+
+  // fetchModelFailed reducer
+  it('fetchModelFailed Reducer', () => {
+    const reducer = fetchModelFailedReducer(appStateMock);
+
+    return expect(reducer).toStrictEqual({
+      ...appStateMock,
+      meta: {
+        ...appStateMock.meta,
+        fetchStatus: 'failed',
+      },
+    });
+  });
+});

package/src/redux/reducers/app/pagination/goNextPage.ts

@@ -0,0 +1,69 @@
+import { StateType } from '../../../../types/State.type';
+
+export const goNextPageReducer = (state: StateType.App): StateType.App => {
+  const currentPage = state.pagination.currentPage + 1;
+
+  // Making sure value has changed before changing the state
+  if (
+    state.pagination.currentPage === currentPage ||
+    state.pagination.totalPages < currentPage
+  )
+    return state;
+
+  // Greatest page
+  const greatestPage =
+    state.pagination.greatestPage > currentPage
+      ? state.pagination.greatestPage
+      : currentPage;
+
+  // Checking first/last page
+  const isLastPage = currentPage === state.pagination.totalPages;
+  const isFirstPage = false;
+
+  /**
+   * Calculating
+   * - Current Section ID
+   * - Current App State
+   */
+
+  // Available section
+  const { availableSections } = state.wizard;
+
+  // Wizard indexes
+  const wizardIndexBegin =
+    state.pagination.availableAppStates.indexOf('wizard');
+  const wizardIndexEnd =
+    wizardIndexBegin + state.wizard.availableSections.length;
+
+  // Calculating everything
+  let currentAppStateIndex;
+  let currentSectionId;
+  if (currentPage - 1 < wizardIndexBegin) {
+    currentAppStateIndex = currentPage - 1;
+    [currentSectionId] = availableSections;
+  } else if (currentPage - 1 < wizardIndexEnd) {
+    currentAppStateIndex = wizardIndexBegin;
+    currentSectionId = availableSections[currentPage - wizardIndexBegin - 1];
+  } else {
+    currentAppStateIndex = currentPage - wizardIndexEnd + wizardIndexBegin;
+    currentSectionId = availableSections[availableSections.length - 1];
+  }
+  const currentAppState =
+    state.pagination.availableAppStates[currentAppStateIndex];
+
+  return {
+    ...state,
+    pagination: {
+      ...state.pagination,
+      currentPage,
+      greatestPage,
+      currentAppState,
+      isLastPage,
+      isFirstPage,
+    },
+    wizard: {
+      ...state.wizard,
+      currentSectionId,
+    },
+  };
+};

package/src/redux/reducers/app/pagination/goPage.ts

@@ -0,0 +1,81 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+
+export const goPageReducer = (
+  state: StateType.App,
+  action: ActionsType.App.goPage
+): StateType.App => {
+  const { currentPage } = action;
+
+  // AppStatesArray
+  let appStatesPagesArray: string[] = [];
+  state.pagination.availableAppStates.forEach((_appState) => {
+    if (_appState === 'wizard')
+      appStatesPagesArray = [
+        ...appStatesPagesArray,
+        ...new Array(state.wizard.availableSections.length).fill(_appState),
+      ];
+    else appStatesPagesArray = [...appStatesPagesArray, _appState];
+  });
+
+  const currentAppState = appStatesPagesArray[currentPage - 1];
+
+  // Making sure value has changed before changing the state
+  if (
+    (state.pagination.currentPage === currentPage ||
+      state.pagination.totalPages < currentPage) &&
+    currentAppState === state.pagination.currentAppState
+  )
+    return state;
+
+  // Greatest page
+  const greatestPage =
+    state.pagination.greatestPage > currentPage
+      ? state.pagination.greatestPage
+      : currentPage;
+
+  /**
+   * Calculating
+   * - Current Section ID
+   * - Current App State
+   */
+
+  // Available section
+  const { availableSections } = state.wizard;
+
+  // Wizard indexes
+  const wizardIndexBegin =
+    state.pagination.availableAppStates.indexOf('wizard');
+  const wizardIndexEnd =
+    wizardIndexBegin + state.wizard.availableSections.length;
+
+  // Calculating everything
+  let currentSectionId;
+  if (currentPage - 1 < wizardIndexBegin) {
+    [currentSectionId] = availableSections;
+  } else if (currentPage - 1 < wizardIndexEnd) {
+    currentSectionId = availableSections[currentPage - wizardIndexBegin - 1];
+  } else {
+    currentSectionId = availableSections[availableSections.length - 1];
+  }
+
+  // Checking first/last page
+  const isFirstPage = currentPage === 1;
+  const isLastPage = currentPage === state.pagination.totalPages;
+
+  return {
+    ...state,
+    pagination: {
+      ...state.pagination,
+      currentPage,
+      greatestPage,
+      currentAppState,
+      isFirstPage,
+      isLastPage,
+    },
+    wizard: {
+      ...state.wizard,
+      currentSectionId,
+    },
+  };
+};

package/src/redux/reducers/app/pagination/goPreviousPage.ts

@@ -0,0 +1,60 @@
+import { StateType } from '../../../../types/State.type';
+
+export const goPreviousPageReducer = (state: StateType.App): StateType.App => {
+  const currentPage =
+    state.pagination.currentPage > 1 ? state.pagination.currentPage - 1 : 1;
+
+  // Making sure value has changed before changing the state
+  if (state.pagination.currentPage === currentPage || currentPage < 1)
+    return state;
+
+  // Checking first/last page
+  const isLastPage = false;
+  const isFirstPage = currentPage === 1;
+
+  /**
+   * Calculating
+   * - Current Section ID
+   * - Current App State
+   */
+
+  // Available section
+  const { availableSections } = state.wizard;
+
+  // Wizard indexes
+  const wizardIndexBegin =
+    state.pagination.availableAppStates.indexOf('wizard');
+  const wizardIndexEnd =
+    wizardIndexBegin + state.wizard.availableSections.length;
+
+  // Calculating everything
+  let currentAppStateIndex;
+  let currentSectionId;
+  if (currentPage - 1 < wizardIndexBegin) {
+    currentAppStateIndex = currentPage - 1;
+    [currentSectionId] = availableSections;
+  } else if (currentPage - 1 < wizardIndexEnd) {
+    currentAppStateIndex = wizardIndexBegin;
+    currentSectionId = availableSections[currentPage - wizardIndexBegin - 1];
+  } else {
+    currentAppStateIndex = currentPage - wizardIndexEnd + wizardIndexBegin;
+    currentSectionId = availableSections[availableSections.length - 1];
+  }
+  const currentAppState =
+    state.pagination.availableAppStates[currentAppStateIndex];
+
+  return {
+    ...state,
+    pagination: {
+      ...state.pagination,
+      currentPage,
+      currentAppState,
+      isFirstPage,
+      isLastPage,
+    },
+    wizard: {
+      ...state.wizard,
+      currentSectionId,
+    },
+  };
+};

package/src/redux/reducers/app/pagination/initPagination.ts

@@ -0,0 +1,46 @@
+import { ActionsType } from '../../../../types/Actions.type';
+import { StateType } from '../../../../types/State.type';
+import { registerPluginsAppStates } from '../../../../PluginLoader';
+
+export const initPaginationReducer = (
+  state: StateType.App,
+  action: ActionsType.App.initPagination
+): StateType.App => {
+  const {
+    currentPage,
+    currentSectionId,
+    availableSections,
+    greatestPage,
+    currentAppState,
+  } = action;
+
+  const availableAppStates = registerPluginsAppStates(
+    action.availableAppStates
+  );
+
+  // Calculating total pages
+  const totalPages = availableAppStates.length + availableSections.length - 1;
+
+  // Checking first/last page
+  const isFirstPage = currentPage === 1;
+  const isLastPage = currentPage === totalPages;
+
+  return {
+    ...state,
+    pagination: {
+      ...state.pagination,
+      currentPage,
+      greatestPage,
+      availableAppStates,
+      currentAppState,
+      totalPages,
+      isFirstPage,
+      isLastPage,
+    },
+    wizard: {
+      ...state.wizard,
+      currentSectionId,
+      availableSections,
+    },
+  };
+};