@zeniai/client-epic-state 4.13.15 → 4.13.16

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

@@ -0,0 +1,205 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reviewFluxAnalysisViewFailure = exports.reviewFluxAnalysisViewSuccess = exports.reviewFluxAnalysisView = exports.markFullFluxAnalysisViewForReview = exports.updateOperatingExpensesIdsForReview = exports.clearExpenseAutomationFluxAnalysisView = exports.fetchFluxAnalysisViewFailure = exports.fetchFluxAnalysisViewSuccess = exports.fetchFluxAnalysisView = exports.toReviewStatusById = exports.toFluxAnalysisOperatingEexpense = exports.toFluxAnalysisOperatingEexpenses = exports.toFluxAnalysisiOperatingExpensesById = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const helpers_1 = require("../helpers/helpers");
+exports.initialState = {
+    reviewStatusById: {},
+    operatingExpenseById: {},
+    fluxAnalysisEntities: { operatingExpenses: [] },
+    uiState: {
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+        pageToken: null,
+        totalCount: 0,
+        limit: 10,
+        sortKey: 'vendors',
+        searchString: '',
+        sortOrder: 'ascending',
+    },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    fetchState: 'Not-Started',
+    bulkReviewStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    error: undefined,
+    fluxAnalysisReportGenerated: false,
+    reviewOperatingExpensesIds: [],
+    isAllRowsSelected: false,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationFluxAnalysisView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchFluxAnalysisView: {
+            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(monthAndYear, refreshViewInBackground) {
+                return {
+                    payload: {
+                        monthAndYear,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchFluxAnalysisViewSuccess(draft, action) {
+            const { expensesPayload, currency } = action.payload;
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            draft.reviewStatusById = (0, exports.toReviewStatusById)(expensesPayload);
+            draft.operatingExpenseById = (0, exports.toFluxAnalysisiOperatingExpensesById)(expensesPayload, currency);
+            draft.fluxAnalysisEntities = {
+                operatingExpenses: (0, exports.toFluxAnalysisOperatingEexpenses)(expensesPayload, currency),
+            };
+        },
+        fetchFluxAnalysisViewFailure(draft, action) {
+            const { status } = action.payload;
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+            }
+        },
+        updateOperatingExpensesIdsForReview(draft, action) {
+            const { operatingExpenseIds } = action.payload;
+            if (draft.reviewOperatingExpensesIds.length == 0) {
+                draft.reviewOperatingExpensesIds = operatingExpenseIds;
+            }
+            else {
+                draft.reviewOperatingExpensesIds =
+                    draft.reviewOperatingExpensesIds.concat(operatingExpenseIds);
+            }
+        },
+        markFullFluxAnalysisViewForReview(draft, action) {
+            const { isSelected } = action.payload;
+            const allRowIds = Object.keys(draft.operatingExpenseById);
+            draft.reviewOperatingExpensesIds = allRowIds;
+            draft.isAllRowsSelected = isSelected;
+        },
+        reviewFluxAnalysisView: {
+            reducer(draft, action) {
+                const { operatingExpenseIds } = action.payload;
+                operatingExpenseIds.forEach((id) => {
+                    draft.reviewStatusById[id] = {
+                        fetchState: 'In-Progress',
+                    };
+                });
+                if (operatingExpenseIds.length > 1) {
+                    draft.bulkReviewStatus = {
+                        fetchState: 'In-Progress',
+                    };
+                }
+            },
+            prepare(actionType, operatingExpenseIds) {
+                return {
+                    payload: { actionType, operatingExpenseIds },
+                };
+            },
+        },
+        reviewFluxAnalysisViewSuccess(draft, action) {
+            const { operatingExpenseIds } = action.payload;
+            operatingExpenseIds.forEach((id) => {
+                delete draft.operatingExpenseById[id];
+                draft.reviewStatusById[id] = {
+                    fetchState: 'Completed',
+                };
+            });
+            if (operatingExpenseIds.length > 1) {
+                draft.bulkReviewStatus = {
+                    fetchState: 'Completed',
+                };
+            }
+        },
+        reviewFluxAnalysisViewFailure(draft, action) {
+            const { operatingExpenseIds, status } = action.payload;
+            operatingExpenseIds.forEach((id) => {
+                if (draft.reviewStatusById[id].fetchState === 'In-Progress') {
+                    draft.reviewStatusById[id].fetchState = 'Error';
+                    draft.reviewStatusById[id].error = status;
+                }
+            });
+            if (operatingExpenseIds.length > 1) {
+                draft.bulkReviewStatus = {
+                    fetchState: 'Error',
+                    error: status,
+                };
+            }
+        },
+        clearExpenseAutomationFluxAnalysisView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+const toFluxAnalysisiOperatingExpensesById = (operatingExpenses, currency) => {
+    const balancesByVendorKey = {};
+    operatingExpenses.forEach((operatingExpense) => {
+        const vendorFluxKey = operatingExpense.flux_analysis_entity_id;
+        balancesByVendorKey[vendorFluxKey] = (0, exports.toFluxAnalysisOperatingEexpense)(operatingExpense, currency);
+    });
+    return balancesByVendorKey;
+};
+exports.toFluxAnalysisiOperatingExpensesById = toFluxAnalysisiOperatingExpensesById;
+const toFluxAnalysisOperatingEexpenses = (operatingExpensesPayload, currency) => {
+    const operatingExpenses = [];
+    operatingExpensesPayload.forEach((operatingExpensePayload) => {
+        operatingExpenses.push((0, exports.toFluxAnalysisOperatingEexpense)(operatingExpensePayload, currency));
+    });
+    return operatingExpenses;
+};
+exports.toFluxAnalysisOperatingEexpenses = toFluxAnalysisOperatingEexpenses;
+const toFluxAnalysisOperatingEexpense = (operatingExpensePayload, currency) => {
+    var _a;
+    return {
+        operatingExpenseId: operatingExpensePayload.flux_analysis_entity_id,
+        vendorId: operatingExpensePayload.vendor_id,
+        accountId: operatingExpensePayload.account_id,
+        classId: operatingExpensePayload.accounting_class_id,
+        userId: (_a = operatingExpensePayload.reviewed_by_user_id) !== null && _a !== void 0 ? _a : undefined,
+        varianceAmount: operatingExpensePayload.variance_amount,
+        variancePercentage: operatingExpensePayload.variance_percentage,
+        currency: {
+            currencyCode: currency.currency_code,
+            currencySymbol: currency.currency_symbol,
+        },
+        anomalyReason: operatingExpensePayload.anomaly_reason,
+        status: (0, helpers_1.toVendorFluxAnalysisStatusFromPayload)(operatingExpensePayload.status),
+        balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(operatingExpensePayload.month_1, operatingExpensePayload.month_2, currency),
+    };
+};
+exports.toFluxAnalysisOperatingEexpense = toFluxAnalysisOperatingEexpense;
+const toReviewStatusById = (operatingExpenses) => {
+    const reviewStatusById = {};
+    operatingExpenses.forEach((operatingExpense) => {
+        reviewStatusById[operatingExpense.flux_analysis_entity_id] = {
+            fetchState: 'Not-Started',
+            error: undefined,
+        };
+    });
+    return reviewStatusById;
+};
+exports.toReviewStatusById = toReviewStatusById;
+_a = expenseAutomationFluxAnalysisView.actions, exports.fetchFluxAnalysisView = _a.fetchFluxAnalysisView, exports.fetchFluxAnalysisViewSuccess = _a.fetchFluxAnalysisViewSuccess, exports.fetchFluxAnalysisViewFailure = _a.fetchFluxAnalysisViewFailure, exports.clearExpenseAutomationFluxAnalysisView = _a.clearExpenseAutomationFluxAnalysisView, exports.updateOperatingExpensesIdsForReview = _a.updateOperatingExpensesIdsForReview, exports.markFullFluxAnalysisViewForReview = _a.markFullFluxAnalysisViewForReview, exports.reviewFluxAnalysisView = _a.reviewFluxAnalysisView, exports.reviewFluxAnalysisViewSuccess = _a.reviewFluxAnalysisViewSuccess, exports.reviewFluxAnalysisViewFailure = _a.reviewFluxAnalysisViewFailure;
+exports.default = expenseAutomationFluxAnalysisView.reducer;

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;