@zeniai/client-epic-state 4.12.98 → 4.12.99

package/lib/view/expenseAutomationView/reducers/jeSchedulesViewReducer.d.ts

@@ -0,0 +1,53 @@
+import { ID } from '../../../commonStateTypes/common';
+import { JEScheduleLocalData, JESchedulesViewState } from '../types/jeSchedulesViewState';
+import { TimePeriod, MonthYearPeriod } from '../../../commonStateTypes/timePeriod';
+import { JEScheduleTransactionKey } from '../../../entity/jeSchedules/jeSchedulesTypes';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { JEScheduledTransactionPayload } from '../../../entity/jeSchedules/jeSchedulesPayload';
+export declare const initialState: JESchedulesViewState;
+export declare const clearExpenseAutomationJESchedulesView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>, fetchJeSchedules: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[period: TimePeriod, refreshViewInBackground?: any], {
+    period: TimePeriod;
+    refreshViewInBackground: any;
+}, string, never, never>, fetchJeSchedulesFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedPeriod: MonthYearPeriod;
+    status: ZeniAPIStatus;
+}, string>, fetchJeSchedulesSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    jeSchedules: JEScheduledTransactionPayload[];
+    failedJeSchedules: JEScheduledTransactionPayload[];
+    selectedPeriod: MonthYearPeriod;
+}, string>, fetchJeSchedulesPage: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[period: TimePeriod, refreshViewInBackground?: any], {
+    period: TimePeriod;
+    refreshViewInBackground: any;
+}, string, never, never>, ignoreRecommendedJeSchedule: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[jeScheduleTransactionKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`, scheduleType: "prepaid_expenses" | "fixed_assets" | "accrued_expenses" | "deferred_revenue"], {
+    jeScheduleTransactionKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`;
+    scheduleType: "prepaid_expenses" | "fixed_assets" | "accrued_expenses" | "deferred_revenue";
+}, string, never, never>, ignoreRecommendedJeScheduleFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    jeScheduleTransactionKey: JEScheduleTransactionKey;
+    status: ZeniAPIStatus;
+}, string>, ignoreRecommendedJeScheduleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[jeScheduleTransactionKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`], {
+    jeScheduleTransactionKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`;
+}, string, never, never>, initializeJeScheduleLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[jeSchedules: JEScheduledTransactionPayload[]], {
+    jeScheduleTransactionKeys: (`${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`)[];
+}, string, never, never>, removeJeScheduleTransactionKey: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[jeScheduleKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`, selectedPeriod: MonthYearPeriod], {
+    jeScheduleKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`;
+    selectedPeriod: MonthYearPeriod;
+}, string, never, never>, removeFailedJeScheduleTransactionKey: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[failedJeScheduleKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`, selectedPeriod: MonthYearPeriod], {
+    failedJeScheduleKey: `${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`;
+    selectedPeriod: MonthYearPeriod;
+}, string, never, never>, retryJeSchedule: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    scheduledJournalEntryID: ID;
+    jeScheduleTransactionKey: JEScheduleTransactionKey;
+}, string>, retryJeScheduleFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    scheduledJournalEntryID: ID;
+    status: ZeniAPIStatus;
+}, string>, retryJeScheduleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    scheduledJournalEntryID: ID;
+}, string>, updateJeScheduleLocalDataById: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    scheduledJournalEntryID: ID;
+    localData: Partial<JEScheduleLocalData>;
+}, string>, updateJeScheduleTransactionKeys: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[jeScheduleKeys: (`${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`)[], selectedPeriod: MonthYearPeriod], {
+    jeScheduleKeys: (`${string}_invoice` | `${string}_payment` | `${string}_credit_memo` | `${string}_sales_receipt` | `${string}_delayed_credit` | `${string}_delayed_charge` | `${string}_refund` | `${string}_expense` | `${string}_check` | `${string}_bill` | `${string}_bill_payment` | `${string}_bill_payment_check` | `${string}_bill_payment_credit_card` | `${string}_vendor_credit` | `${string}_credit_card_credit` | `${string}_transfer` | `${string}_credit_card_payment` | `${string}_deposit` | `${string}_journal_entry`)[];
+    selectedPeriod: MonthYearPeriod;
+}, string, never, never>;
+declare const _default: import("@reduxjs/toolkit").Reducer<JESchedulesViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

package/lib/view/expenseAutomationView/reducers/jeSchedulesViewReducer.js

@@ -0,0 +1,245 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateJeScheduleTransactionKeys = exports.updateJeScheduleLocalDataById = exports.retryJeScheduleSuccess = exports.retryJeScheduleFailure = exports.retryJeSchedule = exports.removeFailedJeScheduleTransactionKey = exports.removeJeScheduleTransactionKey = exports.initializeJeScheduleLocalData = exports.ignoreRecommendedJeScheduleSuccess = exports.ignoreRecommendedJeScheduleFailure = exports.ignoreRecommendedJeSchedule = exports.fetchJeSchedulesPage = exports.fetchJeSchedulesSuccess = exports.fetchJeSchedulesFailure = exports.fetchJeSchedules = exports.clearExpenseAutomationJESchedulesView = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const jeSchedulesPayload_1 = require("../../../entity/jeSchedules/jeSchedulesPayload");
+const transactionIDPayload_1 = require("../../../entity/transaction/payloadTypes/transactionIDPayload");
+const transactionDetailState_1 = require("../../transactionDetail/transactionDetailState");
+exports.initialState = {
+    jeScheduleTransactionKeysByPeriod: {},
+    failedJeScheduleTransactionKeysByPeriod: {},
+    postStatusById: {},
+    ignoreStatusById: {},
+    jeScheduleLocalDataById: {},
+    uiState: {
+        searchString: '',
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+        totalCount: 0,
+        limit: 10,
+    },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationJESchedulesView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationJESchedulesView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchJeSchedulesPage: {
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+            reducer() {
+                // Do nothing
+            },
+        },
+        fetchJeSchedules: {
+            reducer(draft, action) {
+                const { refreshViewInBackground } = action.payload;
+                if (refreshViewInBackground) {
+                    draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                }
+                else {
+                    draft.fetchState = 'In-Progress';
+                    draft.error = undefined;
+                }
+            },
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchJeSchedulesSuccess(draft, action) {
+            const { jeSchedules, selectedPeriod, failedJeSchedules } = action.payload;
+            const jeScheduleTransactionKeys = jeSchedules.map((schedules) => {
+                const transactionID = (0, transactionIDPayload_1.toTransactionID)(schedules.base_transaction);
+                return (0, transactionDetailState_1.getZeniTransactionDetailKey)(transactionID);
+            });
+            const failedJeScheduleTransactionKeys = failedJeSchedules.map((schedules) => {
+                const transactionID = (0, transactionIDPayload_1.toTransactionID)(schedules.base_transaction);
+                return (0, transactionDetailState_1.getZeniTransactionDetailKey)(transactionID);
+            });
+            if (draft.refreshStatus.fetchState === 'In-Progress') {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            else {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+            draft.jeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = jeScheduleTransactionKeys;
+            draft.failedJeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = failedJeScheduleTransactionKeys;
+        },
+        fetchJeSchedulesFailure(draft, action) {
+            const { status, selectedPeriod } = action.payload;
+            if (draft.refreshStatus.fetchState === 'In-Progress') {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+            }
+            else {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+            draft.jeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+        },
+        retryJeSchedule(draft, action) {
+            const { scheduledJournalEntryID } = action.payload;
+            const prevData = draft.postStatusById;
+            draft.postStatusById = Object.assign(Object.assign({}, prevData), { [scheduledJournalEntryID]: {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                } });
+        },
+        retryJeScheduleSuccess(draft, action) {
+            const { scheduledJournalEntryID } = action.payload;
+            const prevData = draft.postStatusById;
+            draft.postStatusById = Object.assign(Object.assign({}, prevData), { [scheduledJournalEntryID]: {
+                    fetchState: 'Completed',
+                    error: undefined,
+                } });
+        },
+        retryJeScheduleFailure(draft, action) {
+            const { status, scheduledJournalEntryID } = action.payload;
+            const prevData = draft.postStatusById;
+            draft.postStatusById = Object.assign(Object.assign({}, prevData), { [scheduledJournalEntryID]: {
+                    fetchState: 'Error',
+                    error: status,
+                } });
+        },
+        ignoreRecommendedJeSchedule: {
+            prepare(jeScheduleTransactionKey, scheduleType) {
+                return {
+                    payload: {
+                        jeScheduleTransactionKey,
+                        scheduleType,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const { jeScheduleTransactionKey } = action.payload;
+                const prevData = draft.ignoreStatusById;
+                draft.ignoreStatusById = Object.assign(Object.assign({}, prevData), { [jeScheduleTransactionKey]: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    } });
+            },
+        },
+        ignoreRecommendedJeScheduleSuccess: {
+            reducer(draft, action) {
+                const { jeScheduleTransactionKey } = action.payload;
+                const prevData = draft.ignoreStatusById;
+                draft.ignoreStatusById = Object.assign(Object.assign({}, prevData), { [jeScheduleTransactionKey]: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                    } });
+            },
+            prepare(jeScheduleTransactionKey) {
+                return {
+                    payload: {
+                        jeScheduleTransactionKey,
+                    },
+                };
+            },
+        },
+        ignoreRecommendedJeScheduleFailure(draft, action) {
+            const { status, jeScheduleTransactionKey } = action.payload;
+            const prevData = draft.ignoreStatusById;
+            draft.ignoreStatusById = Object.assign(Object.assign({}, prevData), { [jeScheduleTransactionKey]: {
+                    fetchState: 'Error',
+                    error: status,
+                } });
+        },
+        updateJeScheduleTransactionKeys: {
+            prepare(jeScheduleKeys, selectedPeriod) {
+                return {
+                    payload: {
+                        jeScheduleKeys: jeScheduleKeys,
+                        selectedPeriod: selectedPeriod,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                const { selectedPeriod, jeScheduleKeys } = action.payload;
+                draft.jeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = jeScheduleKeys;
+            },
+        },
+        removeJeScheduleTransactionKey: {
+            prepare(jeScheduleKey, selectedPeriod) {
+                return {
+                    payload: {
+                        jeScheduleKey: jeScheduleKey,
+                        selectedPeriod: selectedPeriod,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                var _a;
+                const { selectedPeriod, jeScheduleKey } = action.payload;
+                const prevData = [
+                    ...((_a = draft.jeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]) !== null && _a !== void 0 ? _a : []),
+                ];
+                const filteredKeys = prevData.filter((jeKey) => jeKey !== jeScheduleKey);
+                draft.jeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = filteredKeys;
+            },
+        },
+        removeFailedJeScheduleTransactionKey: {
+            prepare(failedJeScheduleKey, selectedPeriod) {
+                return {
+                    payload: {
+                        failedJeScheduleKey: failedJeScheduleKey,
+                        selectedPeriod: selectedPeriod,
+                    },
+                };
+            },
+            reducer(draft, action) {
+                var _a;
+                const { selectedPeriod, failedJeScheduleKey } = action.payload;
+                const prevData = [
+                    ...((_a = draft.failedJeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)]) !== null && _a !== void 0 ? _a : []),
+                ];
+                const filteredKeys = prevData.filter((jeKey) => jeKey !== failedJeScheduleKey);
+                draft.failedJeScheduleTransactionKeysByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = filteredKeys;
+            },
+        },
+        initializeJeScheduleLocalData: {
+            reducer() {
+                /* DO nothing*/
+            },
+            prepare(jeSchedules) {
+                return {
+                    payload: {
+                        jeScheduleTransactionKeys: [
+                            ...jeSchedules.map((jeSchedule) => (0, jeSchedulesPayload_1.getTransactionDetailKeyPayload)(jeSchedule.base_transaction)),
+                        ],
+                    },
+                };
+            },
+        },
+        updateJeScheduleLocalDataById(draft, action) {
+            const { scheduledJournalEntryID, localData } = action.payload;
+            const prevData = draft.jeScheduleLocalDataById;
+            const prevLocalDataById = draft.jeScheduleLocalDataById[scheduledJournalEntryID];
+            draft.jeScheduleLocalDataById = Object.assign(Object.assign({}, prevData), { [scheduledJournalEntryID]: Object.assign(Object.assign({}, prevLocalDataById), localData) });
+        },
+        clearExpenseAutomationJESchedulesView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = expenseAutomationJESchedulesView.actions, exports.clearExpenseAutomationJESchedulesView = _a.clearExpenseAutomationJESchedulesView, exports.fetchJeSchedules = _a.fetchJeSchedules, exports.fetchJeSchedulesFailure = _a.fetchJeSchedulesFailure, exports.fetchJeSchedulesSuccess = _a.fetchJeSchedulesSuccess, exports.fetchJeSchedulesPage = _a.fetchJeSchedulesPage, exports.ignoreRecommendedJeSchedule = _a.ignoreRecommendedJeSchedule, exports.ignoreRecommendedJeScheduleFailure = _a.ignoreRecommendedJeScheduleFailure, exports.ignoreRecommendedJeScheduleSuccess = _a.ignoreRecommendedJeScheduleSuccess, exports.initializeJeScheduleLocalData = _a.initializeJeScheduleLocalData, exports.removeJeScheduleTransactionKey = _a.removeJeScheduleTransactionKey, exports.removeFailedJeScheduleTransactionKey = _a.removeFailedJeScheduleTransactionKey, exports.retryJeSchedule = _a.retryJeSchedule, exports.retryJeScheduleFailure = _a.retryJeScheduleFailure, exports.retryJeScheduleSuccess = _a.retryJeScheduleSuccess, exports.updateJeScheduleLocalDataById = _a.updateJeScheduleLocalDataById, exports.updateJeScheduleTransactionKeys = _a.updateJeScheduleTransactionKeys;
+exports.default = expenseAutomationJESchedulesView.reducer;

package/lib/view/expenseAutomationView/reducers/missingReceiptsViewReducer.d.ts

@@ -0,0 +1,31 @@
+import { MissingReceiptsViewState, MissingReceiptsViewUIState } from '../types/missingReceiptsViewState';
+import { MonthYearPeriod, TimePeriod } from '../../../commonStateTypes/timePeriod';
+import { Amount } from '../../../commonStateTypes/amount';
+import { TransactionPayload } from '../../../entity/transaction/payloadTypes/transactionPayload';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { SupportedTransactionPayload } from '../../../entity/transaction/transactionState';
+import { FetchStateAndError, UpdateType } from '../../../commonStateTypes/common';
+export declare const initialState: MissingReceiptsViewState;
+export declare const fetchMissingReceipts: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[period: TimePeriod, minimumTransactionAmount: Amount, cacheOverride?: any, refreshViewInBackground?: any], {
+    period: TimePeriod;
+    minimumTransactionAmount: Amount;
+    cacheOverride: any;
+    refreshViewInBackground: any;
+}, string, never, never>, fetchMissingReceiptsSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    transactionsPayload: TransactionPayload[];
+    selectedPeriod: MonthYearPeriod;
+}, string>, fetchMissingReceiptsFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedPeriod: MonthYearPeriod;
+    status: ZeniAPIStatus;
+}, string>, uploadMissingReceiptSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionPayload: SupportedTransactionPayload, updateType?: UpdateType | undefined], {
+    transactionPayload: SupportedTransactionPayload;
+    updateType: UpdateType;
+}, string, never, never>, updateMissingReceiptUploadState: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: string, fetchStatus: FetchStateAndError], {
+    transactionId: string;
+    fetchStatus: FetchStateAndError;
+}, string, never, never>, updateMissingReceiptsUIState: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<MissingReceiptsViewUIState>, string>, markMissingReceiptAsDone: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionPayload: SupportedTransactionPayload, selectedPeriod: MonthYearPeriod], {
+    transactionPayload: SupportedTransactionPayload;
+    selectedPeriod: MonthYearPeriod;
+}, string, never, never>, clearExpenseAutomationMissingReceiptsView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<MissingReceiptsViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

package/lib/view/expenseAutomationView/reducers/missingReceiptsViewReducer.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearExpenseAutomationMissingReceiptsView = exports.markMissingReceiptAsDone = exports.updateMissingReceiptsUIState = exports.updateMissingReceiptUploadState = exports.uploadMissingReceiptSuccess = exports.fetchMissingReceiptsFailure = exports.fetchMissingReceiptsSuccess = exports.fetchMissingReceipts = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+exports.initialState = {
+    uploadReceiptStatusById: {},
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    uiState: {
+        sortKey: 'date',
+        sortOrder: 'descending',
+        searchString: '',
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+    },
+    transactionIdsBySelectedPeriod: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationMissingReceiptsView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationMissingReceiptsView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchMissingReceipts: {
+            reducer(draft, action) {
+                const { refreshViewInBackground } = action.payload;
+                if (refreshViewInBackground) {
+                    draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                }
+                else {
+                    draft.fetchState = 'In-Progress';
+                    draft.error = undefined;
+                }
+            },
+            prepare(period, minimumTransactionAmount, cacheOverride = false, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        minimumTransactionAmount,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchMissingReceiptsSuccess(draft, action) {
+            const { transactionsPayload, selectedPeriod } = action.payload;
+            const transactionIds = transactionsPayload.map((transactionPayload) => transactionPayload.transaction_id);
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIds;
+        },
+        fetchMissingReceiptsFailure(draft, action) {
+            const { status, selectedPeriod } = action.payload;
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+            }
+            draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+        },
+        updateMissingReceiptsUIState(draft, action) {
+            if (action.payload.sortKey != null) {
+                draft.uiState.sortKey = action.payload.sortKey;
+            }
+            if (action.payload.sortOrder != null) {
+                draft.uiState.sortOrder = action.payload.sortOrder;
+            }
+            if (action.payload.searchString != null) {
+                draft.uiState.searchString = action.payload.searchString;
+            }
+            if (action.payload.scrollPosition != null) {
+                draft.uiState.scrollPosition = action.payload.scrollPosition;
+            }
+        },
+        updateMissingReceiptUploadState: {
+            reducer(draft, action) {
+                const { transactionId, fetchStatus } = action.payload;
+                draft.uploadReceiptStatusById[transactionId] = fetchStatus;
+            },
+            prepare(transactionId, fetchStatus) {
+                return { payload: { transactionId, fetchStatus } };
+            },
+        },
+        uploadMissingReceiptSuccess: {
+            reducer(draft, action) {
+                const { transactionPayload } = action.payload;
+                draft.uploadReceiptStatusById[transactionPayload.transaction_id] = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            },
+            prepare(transactionPayload, updateType = 'merge') {
+                return { payload: { transactionPayload, updateType } };
+            },
+        },
+        markMissingReceiptAsDone: {
+            reducer(draft, action) {
+                const { transactionPayload, selectedPeriod } = action.payload;
+                if (draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] != null) {
+                    draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].filter((transactionId) => transactionId !== transactionPayload.transaction_id);
+                }
+                else {
+                    draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+                }
+            },
+            prepare(transactionPayload, selectedPeriod) {
+                return { payload: { transactionPayload, selectedPeriod } };
+            },
+        },
+        clearExpenseAutomationMissingReceiptsView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = expenseAutomationMissingReceiptsView.actions, exports.fetchMissingReceipts = _a.fetchMissingReceipts, exports.fetchMissingReceiptsSuccess = _a.fetchMissingReceiptsSuccess, exports.fetchMissingReceiptsFailure = _a.fetchMissingReceiptsFailure, exports.uploadMissingReceiptSuccess = _a.uploadMissingReceiptSuccess, exports.updateMissingReceiptUploadState = _a.updateMissingReceiptUploadState, exports.updateMissingReceiptsUIState = _a.updateMissingReceiptsUIState, exports.markMissingReceiptAsDone = _a.markMissingReceiptAsDone, exports.clearExpenseAutomationMissingReceiptsView = _a.clearExpenseAutomationMissingReceiptsView;
+exports.default = expenseAutomationMissingReceiptsView.reducer;

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.d.ts

@@ -0,0 +1,5 @@
+import { TransactionsViewState } from '../types/transactionsViewState';
+export declare const initialState: TransactionsViewState;
+export declare const clearExpenseAutomationTransactionsView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<TransactionsViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearExpenseAutomationTransactionsView = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    saveStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    updateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    uiState: {
+        sortKey: 'vendor',
+        sortOrder: 'ascending',
+        searchString: '',
+        nodeCollapseState: {},
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+        pageToken: null,
+        totalCount: 0,
+        limit: 10,
+    },
+    selectedTab: 'review',
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationTransactionsView',
+    initialState: exports.initialState,
+    reducers: {
+        clearExpenseAutomationTransactionsView() {
+            // TODO - Vivek
+        },
+    },
+});
+exports.clearExpenseAutomationTransactionsView = expenseAutomationTransactionsView.actions.clearExpenseAutomationTransactionsView;
+exports.default = expenseAutomationTransactionsView.reducer;

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.d.ts

@@ -0,0 +1,35 @@
+import { LoggedInUser } from '../../..';
+import { CompletionStatusType, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { MonthYearPeriod, MonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { MonthEndAuditSummary, MonthEndCloseChecksState } from '../../../entity/monthEndCloseChecks/monthEndCloseChecksState';
+import { MonthEndCloseChecksView } from '../../../view/monthEndCloseChecksView/monthEndCloseChecksViewSelector';
+import { CompanyMonthEndReportSelectorView } from '../../companyMonthEndReportView/companyMonthEndReportViewSelector';
+import { ExpenseAutomationViewType } from '../expenseAutomationViewState';
+import { ExpenseAutomationJESchedulesViewSelector } from './jeSchedulesSelectorTypes';
+import { ExpenseAutomationFluxAnalysisViewSelector } from './fluxAnalysisViewSelectorTypes';
+import { ExpenseAutomationMissingReceiptsViewSelector } from './missingReceiptsSelectorTypes';
+export interface ExpenseAutomationStepDetails {
+    step: ExpenseAutomationViewType;
+    title: string;
+    subTitle: string;
+    completionStatus: CompletionStatusType;
+    isDisabled: boolean;
+    isPrevDisabled: boolean;
+    isNextDisabled: boolean;
+}
+export declare const getAllSteps: (monthEndCloseChecksState: MonthEndCloseChecksState, monthYearId: MonthYearPeriodId, tenantId: ID, auditSummary?: MonthEndAuditSummary | undefined, loggedInUser?: LoggedInUser | undefined) => ExpenseAutomationStepDetails[];
+export interface ExpenseAutomationViewSelector extends SelectorView {
+    currentSelectedView: ExpenseAutomationViewType;
+    selectedPeriod: MonthYearPeriod;
+    monthEndCloseChecksView: MonthEndCloseChecksView;
+    jeSchedules: ExpenseAutomationJESchedulesViewSelector;
+    missingReceipts: ExpenseAutomationMissingReceiptsViewSelector;
+    fluxAnalysis: ExpenseAutomationFluxAnalysisViewSelector;
+    monthEndInsights?: CompanyMonthEndReportSelectorView;
+    saveStatus: FetchStateAndError;
+    updateStatus: FetchStateAndError;
+    allSteps: ExpenseAutomationStepDetails[];
+    completionStatus: CompletionStatusType;
+    auditSummary?: MonthEndAuditSummary;
+}

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllSteps = void 0;
+const common_1 = require("../../../commonStateTypes/common");
+const getAllSteps = (monthEndCloseChecksState, monthYearId, tenantId, auditSummary, loggedInUser) => {
+    var _a, _b;
+    if (((_a = monthEndCloseChecksState.monthEndCloseChecksByTenantId[tenantId]) === null || _a === void 0 ? void 0 : _a[monthYearId]) != null) {
+        const steps = monthEndCloseChecksState.monthEndCloseChecksByTenantId[tenantId][monthYearId].monthEndCloseCheckList.map((check) => {
+            switch (check.id) {
+                case 'month_end_insights':
+                    return {
+                        step: check.id,
+                        title: check.title,
+                        subTitle: check.description,
+                        completionStatus: check.progress === 100
+                            ? (0, common_1.toCompletionStatusType)('complete')
+                            : (0, common_1.toCompletionStatusType)('incomplete'),
+                        isDisabled: auditSummary == null || auditSummary.auditScorePercentage < 75,
+                        isPrevDisabled: false,
+                        isNextDisabled: false,
+                    };
+                case 'account_recon':
+                case 'je_schedules':
+                case 'missing_receipts':
+                case 'flux_analysis':
+                case 'transaction_categorization':
+                    return {
+                        step: check.id,
+                        title: check.title,
+                        subTitle: check.description,
+                        completionStatus: check.progress === 100
+                            ? (0, common_1.toCompletionStatusType)('complete')
+                            : (0, common_1.toCompletionStatusType)('incomplete'),
+                        isDisabled: false,
+                        isPrevDisabled: false,
+                        isNextDisabled: false,
+                    };
+            }
+        });
+        if (((_b = loggedInUser === null || loggedInUser === void 0 ? void 0 : loggedInUser.userEmail) === null || _b === void 0 ? void 0 : _b.includes('zeni.ai')) === false) {
+            return steps.filter((step) => step.step !== 'month_end_insights');
+        }
+        return steps;
+    }
+    return [];
+};
+exports.getAllSteps = getAllSteps;

package/lib/view/expenseAutomationView/selectorTypes/fluxAnalysisViewSelectorTypes.d.ts

@@ -0,0 +1,32 @@
+import { Currency } from '../../../commonStateTypes/amount';
+import { FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { User } from '../../../entity/user/userState';
+import { Vendor } from '../../../entity/vendor/vendorState';
+import { ZeniDate } from '../../../zeniDayJS';
+import { FluxAnalysisReviewStatus, FluxAnalysisViewUIState, FluxBalancesByMonth } from '../types/fluxAnalysisViewState';
+export interface FluxAnalysisOperatingExpenseView {
+    operatingExpenseId: ID;
+    vendor: Vendor;
+    accountBase: AccountBase | undefined;
+    classBase: ClassBase | undefined;
+    reviewedByUser: User | undefined;
+    varianceAmount: number;
+    variancePercentage: number;
+    currency: Currency;
+    anomalyReason: string;
+    status: FluxAnalysisReviewStatus;
+    balancesByMonth?: FluxBalancesByMonth;
+    reviewStatus: FetchStateAndError;
+}
+export interface ExpenseAutomationFluxAnalysisViewSelector {
+    operatingExpensesView: FluxAnalysisOperatingExpenseView[];
+    reviewOperatingExpensesIds: ID[];
+    fetchStatus: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    bulkReviewStatus: FetchStateAndError;
+    uiState: FluxAnalysisViewUIState;
+    lastRefreshSuccessTime?: ZeniDate;
+    isAllSelected: boolean;
+}

package/lib/view/expenseAutomationView/selectorTypes/fluxAnalysisViewSelectorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });