@zeniai/client-epic-state 4.15.34 → 4.15.36

package/lib/view/expenseAutomationView/payload/reconciliationPayload.d.ts

@@ -0,0 +1,28 @@
+import { MonthYearPeriod } from '../../../commonStateTypes/timePeriod';
+import { AccountPayload } from '../../../entity/account/accountPayload';
+import { ReconciliationDataPayload, TransactionsToReviewPayload } from '../../../entity/accountRecon/accountReconPayload';
+import { AccountReconciliationEntity } from '../../../entity/accountRecon/accountReconSelector';
+import { MatchedTransactionPayload } from '../../../entity/transaction/payloadTypes/reconciliationTransactionPayloads';
+import { UserPayload } from '../../../entity/user/userPayload';
+import { RootState } from '../../../reducer';
+import { ZeniAPIResponse } from '../../../responsePayload';
+import { BalancesLocalData, SaveReconcileDetailActionPayload } from '../types/reconciliationViewState';
+export interface AccountAndPaymentAccountPayload extends AccountPayload {
+    payment_account_id: string | null;
+}
+export interface ReconciliationPayload {
+    accounts: AccountAndPaymentAccountPayload[];
+    reconciliation: ReconciliationDataPayload[];
+    users: UserPayload[];
+}
+export type ReconciliationResponse = ZeniAPIResponse<ReconciliationPayload>;
+export interface SaveReconciliationReviewPayload {
+    reconciliation: MatchedTransactionPayload;
+}
+export type SaveReconciliationReviewResponse = ZeniAPIResponse<SaveReconciliationReviewPayload>;
+export declare function createSaveReconciliationPayloadBasedOnActionAndMethod(state: RootState, selectedPeriod: MonthYearPeriod, localData: BalancesLocalData, accountReconciliationEntity: AccountReconciliationEntity, action: SaveReconcileDetailActionPayload, method: 'PUT' | 'POST'): {
+    transactions: {
+        reconcile: MatchedTransactionPayload[];
+        review: TransactionsToReviewPayload[];
+    };
+};

package/lib/view/expenseAutomationView/payload/reconciliationPayload.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSaveReconciliationPayloadBasedOnActionAndMethod = createSaveReconciliationPayloadBasedOnActionAndMethod;
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountReconPayload_1 = require("../../../entity/accountRecon/accountReconPayload");
+const reconciliationTransactionPayloads_1 = require("../../../entity/transaction/payloadTypes/reconciliationTransactionPayloads");
+function createSaveReconciliationPayloadBasedOnActionAndMethod(state, selectedPeriod, localData, accountReconciliationEntity, action, method) {
+    var _a;
+    const { balance, initialClearedBalance } = accountReconciliationEntity;
+    const { expenseAutomationReconciliationViewState: { selectedAccountId, reconTabsState: { reconcile: { localData: { selectedTransactionIds }, }, }, }, } = state;
+    const period = (0, timePeriod_1.convertToPeriod)(selectedPeriod, true);
+    let payload = {};
+    payload = Object.assign({ action: action.reconcileAction === 'save_reconcile_for_later'
+            ? 'save_for_later'
+            : action.reconcileAction, account_type: 'bank', bank_balance: (_a = balance === null || balance === void 0 ? void 0 : balance.amount) !== null && _a !== void 0 ? _a : 0, cleared_balance: localData.clearedBalance.amount, variance: localData.variance.amount, currency_code: balance === null || balance === void 0 ? void 0 : balance.currencyCode }, ((initialClearedBalance === null || initialClearedBalance === void 0 ? void 0 : initialClearedBalance.amount) != null
+        ? {
+            initial_cleared_balance: initialClearedBalance.amount,
+        }
+        : {}));
+    if (method === 'POST') {
+        payload = Object.assign(Object.assign({}, payload), { account_id: selectedAccountId, start_date: period.start, end_date: period.end });
+    }
+    if (action.reconcileAction === 'exclude') {
+        payload = Object.assign(Object.assign({}, payload), { exclude_transaction_ids: [action.excludeTransactionId] });
+    }
+    const reconciledTransactionsPayload = createReconcileTransactionPayload(selectedTransactionIds, accountReconciliationEntity);
+    const reviewTransactionsPayload = createReviewTransactionPayload(accountReconciliationEntity);
+    return Object.assign(Object.assign({}, payload), { transactions: {
+            reconcile: reconciledTransactionsPayload,
+            review: reviewTransactionsPayload,
+        } });
+}
+function createReconcileTransactionPayload(selectedIds, accountReconciliationEntity) {
+    const matchedTransactionsPayload = [];
+    const matchedReconcileTransactions = accountReconciliationEntity.transactionsToReconcile.map((transaction) => {
+        return Object.assign(Object.assign({}, transaction), { isTransactionChecked: selectedIds.includes(transaction.id) });
+    });
+    matchedReconcileTransactions.forEach((transaction) => {
+        const matchTransactionPayload = (0, reconciliationTransactionPayloads_1.toMatchedTransactionPayload)(transaction);
+        matchedTransactionsPayload.push(matchTransactionPayload);
+    });
+    return matchedTransactionsPayload;
+}
+function createReviewTransactionPayload(accountReconciliationEntity) {
+    const reviewTransactionsPayload = [];
+    accountReconciliationEntity.transactionsToReview.forEach((transaction) => {
+        const matchTransactionPayload = (0, accountReconPayload_1.toTransactionsToReviewPayload)(transaction);
+        reviewTransactionsPayload.push(matchTransactionPayload);
+    });
+    return reviewTransactionsPayload;
+}

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

@@ -0,0 +1,66 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { FetchState, ID } from '../../../commonStateTypes/common';
+import { SortOrder } from '../../../commonStateTypes/selectorTypes/sortOrderTypes';
+import { MonthYearPeriod } from '../../../commonStateTypes/timePeriod';
+import { ZeniAPIStatus } from '../../../responsePayload';
+import { ReconciliationPayload } from '../payload/reconciliationPayload';
+import { ActionFetchStates, ReconReconcileSortKey, ReconReviewSortKey, ReconciliationReviewTabLocalData, ReconciliationTabsState, ReconciliationViewState, ReconciliationViewTabType, SaveReconcileDetailActionPayload, SaveReconciliationDetailFailurePayload, TransactionSummary } from '../types/reconciliationViewState';
+export declare const initialReconciliationTabsState: ReconciliationTabsState;
+export declare const initialActionFetchState: ActionFetchStates;
+export declare const initialState: ReconciliationViewState;
+export declare const fetchReconciliation: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedPeriod: MonthYearPeriod, accountId?: string | undefined, cacheOverride?: any, refreshViewInBackground?: any], {
+    selectedPeriod: MonthYearPeriod;
+    accountId: string | undefined;
+    cacheOverride: any;
+    refreshViewInBackground: any;
+}, "expenseAutomationReconciliationView/fetchReconciliation", never, never>, fetchReconciliationFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedPeriod: MonthYearPeriod;
+    error: ZeniAPIStatus;
+    refreshViewInBackground: boolean;
+    accountId?: ID;
+    reconciliationId?: ID;
+}, "expenseAutomationReconciliationView/fetchReconciliationFailure">, fetchReconciliationSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedPeriod: MonthYearPeriod, reconciliation: ReconciliationPayload, refreshViewInBackground?: any, accountId?: string | undefined, reconciliationId?: string | undefined], {
+    selectedPeriod: MonthYearPeriod;
+    reconciliation: ReconciliationPayload;
+    refreshViewInBackground: any;
+    accountId: string | undefined;
+    reconciliationId: string | undefined;
+}, "expenseAutomationReconciliationView/fetchReconciliationSuccess", never, never>, saveReconciliationDetail: import("@reduxjs/toolkit").ActionCreatorWithPayload<SaveReconcileDetailActionPayload, "expenseAutomationReconciliationView/saveReconciliationDetail">, saveReconciliationDetailFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<SaveReconciliationDetailFailurePayload, "expenseAutomationReconciliationView/saveReconciliationDetailFailure">, updateSelectedAccountId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedAccountId?: ID;
+}, "expenseAutomationReconciliationView/updateSelectedAccountId">, setConnectionInProgressForAccount: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    accountId: ID;
+    connectionInProgress: boolean;
+}, "expenseAutomationReconciliationView/setConnectionInProgressForAccount">, updateReconcileTabLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTransactionIds: ID[];
+}, "expenseAutomationReconciliationView/updateReconcileTabLocalData">, updateReconcileTabListSortState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    sortKey: ReconReconcileSortKey;
+    sortOrder: SortOrder;
+}, "expenseAutomationReconciliationView/updateReconcileTabListSortState">, updateReconcileTabListScrollState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    scrollYOffset: number;
+}, "expenseAutomationReconciliationView/updateReconcileTabListScrollState">, saveReconciliationDetailSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<SaveReconcileDetailActionPayload, "expenseAutomationReconciliationView/saveReconciliationDetailSuccess">, updateSelectedTab: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: ReconciliationViewTabType;
+}, "expenseAutomationReconciliationView/updateSelectedTab">, updateBalancesLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    clearedBalance: Amount;
+    variance: Amount;
+    variancePercentage: number;
+    payments: TransactionSummary;
+    deposits: TransactionSummary;
+}, "expenseAutomationReconciliationView/updateBalancesLocalData">, initialiseLocalDataForSelectedAccountId: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"expenseAutomationReconciliationView/initialiseLocalDataForSelectedAccountId">, clearExpenseAutomationReconciliationView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"expenseAutomationReconciliationView/clearExpenseAutomationReconciliationView">, updateSelectedDrawerAccountId: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedDrawerAccountId?: ID;
+}, "expenseAutomationReconciliationView/updateSelectedDrawerAccountId">, updateReviewTabSortState: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    sortKey: ReconReviewSortKey;
+    sortOrder: SortOrder;
+}, "expenseAutomationReconciliationView/updateReviewTabSortState">, initializeReconciliationReviewTabLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[localData: Record<string, ReconciliationReviewTabLocalData>], {
+    localData: Record<string, ReconciliationReviewTabLocalData>;
+}, "expenseAutomationReconciliationView/initializeReconciliationReviewTabLocalData", never, never>, updateReviewTabLocalData: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    data: ReconciliationReviewTabLocalData;
+    transactionId: ID;
+}, "expenseAutomationReconciliationView/updateReviewTabLocalData">, saveReconciliationReview: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: string], {
+    transactionId: string;
+}, "expenseAutomationReconciliationView/saveReconciliationReview", never, never>, updateSaveReconciliationReviewFetchStatus: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    transactionId: ID;
+    fetchState: FetchState;
+    error?: ZeniAPIStatus;
+}, "expenseAutomationReconciliationView/updateSaveReconciliationReviewFetchStatus">;
+declare const _default: import("redux").Reducer<ReconciliationViewState>;
+export default _default;

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

@@ -0,0 +1,384 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSaveReconciliationReviewFetchStatus = exports.saveReconciliationReview = exports.updateReviewTabLocalData = exports.initializeReconciliationReviewTabLocalData = exports.updateReviewTabSortState = exports.updateSelectedDrawerAccountId = exports.clearExpenseAutomationReconciliationView = exports.initialiseLocalDataForSelectedAccountId = exports.updateBalancesLocalData = exports.updateSelectedTab = exports.saveReconciliationDetailSuccess = exports.updateReconcileTabListScrollState = exports.updateReconcileTabListSortState = exports.updateReconcileTabLocalData = exports.setConnectionInProgressForAccount = exports.updateSelectedAccountId = exports.saveReconciliationDetailFailure = exports.saveReconciliationDetail = exports.fetchReconciliationSuccess = exports.fetchReconciliationFailure = exports.fetchReconciliation = exports.initialState = exports.initialActionFetchState = exports.initialReconciliationTabsState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const accountReconState_1 = require("../../../entity/accountRecon/accountReconState");
+// Initial state
+exports.initialReconciliationTabsState = {
+    balances: {
+        clearedBalance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        variance: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        variancePercentage: 0,
+        deposits: {
+            count: 0,
+            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        },
+        payments: {
+            count: 0,
+            totalAmount: { amount: 0, currencyCode: 'USD', currencySymbol: '$' },
+        },
+    },
+    reconcile: {
+        localData: {
+            selectedTransactionIds: [],
+        },
+        uiState: {
+            scrollYOffset: undefined,
+            sortKey: 'date',
+            sortOrder: 'descending',
+        },
+    },
+    review: {
+        localData: {},
+        uiState: {
+            scrollPosition: undefined,
+            sortKey: 'date',
+            sortOrder: 'descending',
+        },
+    },
+};
+exports.initialActionFetchState = {
+    excludeFetchById: {},
+    reconcileFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveForLaterFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveReconciliationReviewFetch: {},
+};
+exports.initialState = {
+    accountReconciliationRecordsBySelectedPeriod: {},
+    accountConnectionStatusByAccountID: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    selectedTab: 'review',
+    reconTabsState: exports.initialReconciliationTabsState,
+    refreshStatus: { fetchState: 'Not-Started', error: undefined },
+    actionFetchState: exports.initialActionFetchState,
+    selectedAccountId: undefined,
+};
+// Create slice with reducers
+const expenseAutomationReconciliationView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationReconciliationView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchReconciliation: {
+            reducer(draft, action) {
+                if (action.payload.accountId == null) {
+                    if (action.payload.refreshViewInBackground === true) {
+                        draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                    }
+                    else {
+                        draft.fetchState = 'In-Progress';
+                        draft.error = undefined;
+                    }
+                }
+                else {
+                    // select the account for which we are fetching
+                    draft.selectedAccountId = action.payload.accountId;
+                    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)];
+                    const { transactionFetchState } = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
+                    if (transactionFetchState.fetchState !== 'Completed' ||
+                        action.payload.cacheOverride === true) {
+                        const data = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
+                        if (action.payload.refreshViewInBackground === true) {
+                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, data), { refreshStatus: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                }, accountId: action.payload.accountId, reconciliationId: undefined });
+                        }
+                        else {
+                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, data), { transactionFetchState: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                }, accountId: action.payload.accountId, reconciliationId: undefined });
+                        }
+                    }
+                }
+            },
+            prepare(selectedPeriod, accountId, cacheOverride = false, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        selectedPeriod,
+                        accountId,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchReconciliationSuccess: {
+            reducer(draft, action) {
+                if (action.payload.accountId == null) {
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground);
+                }
+                else if (action.payload.reconciliation.reconciliation.length > 0 &&
+                    action.payload.reconciliation.accounts.length > 0) {
+                    updateReconciliationByAccountID(draft, action.payload.reconciliation.accounts[0], action.payload.selectedPeriod, action.payload.accountId, action.payload.reconciliation.reconciliation[0], action.payload.refreshViewInBackground);
+                }
+            },
+            prepare(selectedPeriod, reconciliation, refreshViewInBackground = false, accountId, reconciliationId) {
+                return {
+                    payload: {
+                        selectedPeriod,
+                        reconciliation,
+                        refreshViewInBackground,
+                        accountId,
+                        reconciliationId,
+                    },
+                };
+            },
+        },
+        fetchReconciliationFailure: (draft, action) => {
+            if (action.payload.accountId == null) {
+                if (action.payload.refreshViewInBackground === true) {
+                    draft.refreshStatus = {
+                        fetchState: 'Error',
+                        error: action.payload.error,
+                    };
+                }
+                else {
+                    draft.error = action.payload.error;
+                    draft.fetchState = 'Error';
+                }
+            }
+            else {
+                const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(action.payload.selectedPeriod)];
+                if (action.payload.refreshViewInBackground === true) {
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.error = action.payload.error;
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.fetchState = 'Error';
+                }
+                else {
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.error = action.payload.error;
+                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.fetchState = 'Error';
+                }
+            }
+        },
+        saveReconciliationDetail: (draft, action) => {
+            const { reconcileAction } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    } });
+            }
+        },
+        saveReconciliationDetailFailure: (draft, action) => {
+            const { reconcileAction } = action.payload.fetchStateByAction;
+            const { error } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'Error',
+                    error: error,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'Error',
+                    error: error,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.fetchStateByAction.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'Error',
+                        error: error,
+                    } });
+            }
+        },
+        saveReconciliationDetailSuccess: (draft, action) => {
+            const { reconcileAction } = action.payload;
+            if (reconcileAction === 'reconcile') {
+                draft.actionFetchState.reconcileFetch = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'save_reconcile_for_later') {
+                draft.actionFetchState.saveForLaterFetch = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (reconcileAction === 'exclude') {
+                const excludeTransactionId = action.payload.excludeTransactionId;
+                const excludeFetchStates = draft.actionFetchState.excludeFetchById;
+                draft.actionFetchState.excludeFetchById = Object.assign(Object.assign({}, excludeFetchStates), { [excludeTransactionId]: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                    } });
+            }
+        },
+        updateReconcileTabLocalData: (draft, action) => {
+            const { selectedTransactionIds } = action.payload;
+            draft.reconTabsState.reconcile.localData.selectedTransactionIds =
+                selectedTransactionIds;
+        },
+        updateBalancesLocalData: (draft, action) => {
+            const { clearedBalance, variance, payments, deposits, variancePercentage } = action.payload;
+            draft.reconTabsState.balances = {
+                clearedBalance,
+                variance,
+                variancePercentage,
+                payments: payments,
+                deposits: deposits,
+            };
+        },
+        updateSelectedAccountId: (draft, action) => {
+            draft.selectedAccountId = action.payload.selectedAccountId;
+        },
+        updateSelectedDrawerAccountId: (draft, action) => {
+            draft.selectedDrawerAccountId = action.payload.selectedDrawerAccountId;
+        },
+        initialiseLocalDataForSelectedAccountId: () => { },
+        updateSelectedTab: (draft, action) => {
+            const { selectedTab } = action.payload;
+            draft.selectedTab = selectedTab;
+        },
+        updateReconcileTabListSortState: (draft, action) => {
+            draft.reconTabsState.reconcile.uiState = Object.assign(Object.assign({}, draft.reconTabsState.reconcile.uiState), { sortOrder: action.payload.sortOrder, sortKey: action.payload.sortKey });
+        },
+        updateReviewTabSortState: (draft, action) => {
+            draft.reconTabsState.review.uiState = Object.assign(Object.assign({}, draft.reconTabsState.review.uiState), { sortOrder: action.payload.sortOrder, sortKey: action.payload.sortKey });
+        },
+        updateReconcileTabListScrollState: (draft, action) => {
+            draft.reconTabsState.reconcile.uiState = Object.assign(Object.assign({}, draft.reconTabsState.reconcile.uiState), { scrollYOffset: action.payload.scrollYOffset });
+        },
+        updateReviewTabLocalData(draft, action) {
+            const { data, transactionId } = action.payload;
+            draft.reconTabsState.review.localData = Object.assign(Object.assign({}, draft.reconTabsState.review.localData), { [transactionId]: data });
+        },
+        saveReconciliationReview: {
+            reducer(draft, action) {
+                const { transactionId } = action.payload;
+                draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(transactionId) {
+                return {
+                    payload: {
+                        transactionId,
+                    },
+                };
+            },
+        },
+        updateSaveReconciliationReviewFetchStatus: (draft, action) => {
+            const { transactionId, error, fetchState } = action.payload;
+            draft.actionFetchState.saveReconciliationReviewFetch[transactionId] = {
+                fetchState: fetchState,
+                error,
+            };
+        },
+        initializeReconciliationReviewTabLocalData: {
+            reducer(draft, action) {
+                draft.reconTabsState.review.localData = action.payload.localData;
+            },
+            prepare(localData) {
+                return {
+                    payload: { localData },
+                };
+            },
+        },
+        setConnectionInProgressForAccount: (draft, action) => {
+            if (draft.accountConnectionStatusByAccountID[action.payload.accountId] ==
+                null) {
+                console.error(`Account ${action.payload.accountId} not found to set connection in progress`);
+            }
+            else {
+                draft.accountConnectionStatusByAccountID[action.payload.accountId] = Object.assign(Object.assign({}, draft.accountConnectionStatusByAccountID[action.payload.accountId]), { connectionInProgress: action.payload.connectionInProgress });
+            }
+        },
+        clearExpenseAutomationReconciliationView: (draft) => {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+// Export actions
+_a = expenseAutomationReconciliationView.actions, exports.fetchReconciliation = _a.fetchReconciliation, exports.fetchReconciliationFailure = _a.fetchReconciliationFailure, exports.fetchReconciliationSuccess = _a.fetchReconciliationSuccess, exports.saveReconciliationDetail = _a.saveReconciliationDetail, exports.saveReconciliationDetailFailure = _a.saveReconciliationDetailFailure, exports.updateSelectedAccountId = _a.updateSelectedAccountId, exports.setConnectionInProgressForAccount = _a.setConnectionInProgressForAccount, exports.updateReconcileTabLocalData = _a.updateReconcileTabLocalData, exports.updateReconcileTabListSortState = _a.updateReconcileTabListSortState, exports.updateReconcileTabListScrollState = _a.updateReconcileTabListScrollState, exports.saveReconciliationDetailSuccess = _a.saveReconciliationDetailSuccess, exports.updateSelectedTab = _a.updateSelectedTab, exports.updateBalancesLocalData = _a.updateBalancesLocalData, exports.initialiseLocalDataForSelectedAccountId = _a.initialiseLocalDataForSelectedAccountId, exports.clearExpenseAutomationReconciliationView = _a.clearExpenseAutomationReconciliationView, exports.updateSelectedDrawerAccountId = _a.updateSelectedDrawerAccountId, exports.updateReviewTabSortState = _a.updateReviewTabSortState, exports.initializeReconciliationReviewTabLocalData = _a.initializeReconciliationReviewTabLocalData, exports.updateReviewTabLocalData = _a.updateReviewTabLocalData, exports.saveReconciliationReview = _a.saveReconciliationReview, exports.updateSaveReconciliationReviewFetchStatus = _a.updateSaveReconciliationReviewFetchStatus;
+// Export reducer
+exports.default = expenseAutomationReconciliationView.reducer;
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground) {
+    draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = {
+        accountIDs: [],
+        reconciliationByAccountID: {},
+    };
+    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
+    reconciliationData.forEach((reconciliation) => {
+        var _a, _b, _c;
+        const account = accounts.find((account) => account.account_id === reconciliation.account_id);
+        const oldConnectionStatus = draft.accountConnectionStatusByAccountID[reconciliation.account_id];
+        if (oldConnectionStatus == null) {
+            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
+                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
+                connectionInProgress: false,
+                paymentAccountId: (_a = account === null || account === void 0 ? void 0 : account.payment_account_id) !== null && _a !== void 0 ? _a : undefined,
+            };
+        }
+        else {
+            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
+                status: (0, accountReconState_1.toBankStatusCodeType)(reconciliation.bank_status.code),
+                connectionInProgress: reconciliation.bank_status.code === 'not_connected' &&
+                    oldConnectionStatus.connectionInProgress === true,
+                paymentAccountId: (_b = account === null || account === void 0 ? void 0 : account.payment_account_id) !== null && _b !== void 0 ? _b : undefined,
+            };
+        }
+        accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
+            accountId: reconciliation.account_id,
+            reconciliationId: (_c = reconciliation.reconciliation_id) !== null && _c !== void 0 ? _c : undefined,
+            transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+            refreshStatus: { fetchState: 'Not-Started', error: undefined },
+        };
+        accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
+    });
+    if (refreshViewInBackground === true) {
+        draft.refreshStatus = {
+            fetchState: 'Completed',
+            error: undefined,
+        };
+    }
+    else {
+        draft.fetchState = 'Completed';
+        draft.error = undefined;
+    }
+}
+function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
+    var _a, _b, _c;
+    const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId];
+    const oldConnectionStatus = draft.accountConnectionStatusByAccountID[accountId];
+    draft.accountConnectionStatusByAccountID[accountId] = {
+        status: (0, accountReconState_1.toBankStatusCodeType)(reconciliationData.bank_status.code),
+        connectionInProgress: oldConnectionStatus != null
+            ? reconciliationData.bank_status.code === 'not_connected' &&
+                oldConnectionStatus.connectionInProgress === true
+            : false,
+        paymentAccountId: (_a = accounts.payment_account_id) !== null && _a !== void 0 ? _a : undefined,
+    };
+    if (refreshViewInBackground === true) {
+        draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId] = Object.assign(Object.assign({}, oldRecord), { reconciliationId: (_b = reconciliationData.reconciliation_id) !== null && _b !== void 0 ? _b : undefined, refreshStatus: { fetchState: 'Completed', error: undefined } });
+    }
+    else {
+        draft.accountReconciliationRecordsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].reconciliationByAccountID[accountId] = Object.assign(Object.assign({}, oldRecord), { reconciliationId: (_c = reconciliationData.reconciliation_id) !== null && _c !== void 0 ? _c : undefined, transactionFetchState: { fetchState: 'Completed', error: undefined } });
+    }
+}

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

@@ -4,6 +4,7 @@ import { MonthYearPeriod, TimePeriod } from '../../../commonStateTypes/timePerio
 import { PageToken } from '../../../commonStateTypes/viewAndReport/viewAndReport';
 import { AccountBase } from '../../../entity/account/accountState';
 import { ClassBase } from '../../../entity/class/classState';
+import { CustomerBase } from '../../../entity/customer/customerState';
 import { Entity } from '../../../entity/genericEntity/entity';
 import { RecommendationByLineId, TransactionID } from '../../../entity/transaction/stateTypes/transaction';
 import { SupportedTransaction } from '../../../entity/transaction/transactionState';
@@ -76,12 +77,22 @@ export declare const fetchTransactionCategorization: import("@reduxjs/toolkit").
     selectedTransaction: SupportedTransaction;
     uncategorizedAccounts: UncategorizedAccounts;
     updatedVendor?: VendorBase;
-}, "expenseAutomationTransactionsView/updateSelectedVendorForTransaction">, setAllItemsToCategoryClassInLocalDataForCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionId: string, lineId: string, transactions: SupportedTransaction[], uncategorizedAccounts: UncategorizedAccounts, vendorId?: string | undefined, selectedAccount?: AccountBase | undefined, selectedClassBase?: ClassBase | undefined, lineEntity?: Entity | undefined, recommendations?: Recommendation[] | undefined], {
+    selectedEntity?: Entity;
+}, "expenseAutomationTransactionsView/updateSelectedVendorForTransaction">, updateSelectedCustomerForTransaction: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    selectedTab: TransactionsTab;
+    transactionId: ID;
+    lineId: ID;
+    selectedTransaction: SupportedTransaction;
+    uncategorizedAccounts: UncategorizedAccounts;
+    updatedCustomer?: CustomerBase;
+    selectedEntity?: Entity;
+}, "expenseAutomationTransactionsView/updateSelectedCustomerForTransaction">, setAllItemsToCategoryClassInLocalDataForCategorization: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[selectedTab: "review" | "autoCategorized", transactionId: string, lineId: string, transactions: SupportedTransaction[], uncategorizedAccounts: UncategorizedAccounts, vendorId?: string | undefined, customerId?: string | undefined, selectedAccount?: AccountBase | undefined, selectedClassBase?: ClassBase | undefined, lineEntity?: Entity | undefined, recommendations?: Recommendation[] | undefined], {
     selectedTab: "review" | "autoCategorized";
     transactionId: string;
     lineId: string;
     transactions: SupportedTransaction[];
     vendorId: string | undefined;
+    customerId: string | undefined;
     lineEntity: Entity | undefined;
     selectedAccount: AccountBase | undefined;
     selectedClassBase: ClassBase | undefined;