@zeniai/client-epic-state 5.1.18-betaDI1 → 5.1.18-betaDI3

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

@@ -0,0 +1,683 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
+import { toReconciliationAccountSource } from '../../../entity/account/accountState';
+import { toBankStatusCodeType } from '../../../entity/accountRecon/accountReconState';
+// Initial state
+export const 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',
+        },
+    },
+};
+export const initialActionFetchState = {
+    excludeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    excludeFetchById: {},
+    includeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    reconcileFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveForLaterFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    saveReconciliationReviewFetch: {},
+};
+export const initialState = {
+    accountReconciliationRecordsBySelectedPeriod: {},
+    accountConnectionStatusByAccountID: {},
+    excludedAccountExclusionInfo: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    selectedTab: 'review',
+    reconTabsState: initialReconciliationTabsState,
+    refreshStatus: { fetchState: 'Not-Started', error: undefined },
+    actionFetchState: initialActionFetchState,
+    selectedAccountId: undefined,
+    statementUploadChosen: false,
+    reconListUIState: {
+        nodeCollapseState: {},
+        scrollPosition: {
+            scrollTop: 0,
+        },
+    },
+    excludedAccountIDs: [],
+};
+// Create slice with reducers
+const expenseAutomationReconciliationView = createSlice({
+    name: 'expenseAutomationReconciliationView',
+    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 {
+                    // reset the selected tab to "review" when visiing detail page and we are  not refreshing in Background
+                    if (action.payload.refreshViewInBackground !== true) {
+                        draft.selectedTab = 'review';
+                    }
+                    // select the account for which we are fetching
+                    draft.selectedAccountId = action.payload.accountId;
+                    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[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] = {
+                                ...data,
+                                refreshStatus: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                },
+                                accountId: action.payload.accountId,
+                                reconciliationId: undefined,
+                            };
+                        }
+                        else {
+                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = {
+                                ...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, action.payload.reconciliation.excluded_accounts ?? []);
+                }
+                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[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 = {
+                    ...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 = {
+                    ...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 = {
+                    ...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 = {
+                ...draft.reconTabsState.reconcile.uiState,
+                sortOrder: action.payload.sortOrder,
+                sortKey: action.payload.sortKey,
+            };
+        },
+        updateReviewTabSortState: (draft, action) => {
+            draft.reconTabsState.review.uiState = {
+                ...draft.reconTabsState.review.uiState,
+                sortOrder: action.payload.sortOrder,
+                sortKey: action.payload.sortKey,
+            };
+        },
+        updateReconcileTabListScrollState: (draft, action) => {
+            draft.reconTabsState.reconcile.uiState = {
+                ...draft.reconTabsState.reconcile.uiState,
+                scrollYOffset: action.payload.scrollYOffset,
+            };
+        },
+        updateReviewTabLocalData(draft, action) {
+            const { data, transactionId } = action.payload;
+            draft.reconTabsState.review.localData = {
+                ...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 },
+                };
+            },
+        },
+        updateReconListScrollPosition: (draft, action) => {
+            draft.reconListUIState.scrollPosition = action.payload.scrollPosition;
+        },
+        updateNodeCollapseState: (draft, action) => {
+            draft.reconListUIState.nodeCollapseState[action.payload.nodeId] =
+                action.payload.collapsed;
+        },
+        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] = {
+                    ...draft.accountConnectionStatusByAccountID[action.payload.accountId],
+                    connectionInProgress: action.payload.connectionInProgress,
+                };
+            }
+        },
+        setStatementParseInProgress: (draft, action) => {
+            const { accountId, selectedPeriod, statementParseInProgress } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress =
+                statementParseInProgress;
+        },
+        uploadAccountStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        uploadAccountStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = true;
+        },
+        uploadAccountStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        deleteAccountStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementDeleteStatus = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        deleteAccountStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementDeleteStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        deleteAccountStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementDeleteStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        updateAccountReconciliationLocalData: (draft, action) => {
+            const { accountId, selectedPeriod, localData } = action.payload;
+            const oldLocalData = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData;
+            if (oldLocalData == null) {
+                draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = localData;
+            }
+            else {
+                draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = {
+                    ...oldLocalData,
+                    ...localData,
+                };
+            }
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = {
+                ...oldLocalData,
+                ...localData,
+            };
+        },
+        excludeAccountFromReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.excludeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        excludeAccountFromReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { account, selectedPeriod } = action.payload;
+            if (account != null) {
+                if (!draft.excludedAccountIDs.includes(account.account_id)) {
+                    draft.excludedAccountIDs.push(account.account_id);
+                }
+                updateExcludedAccountExclusionInfo(draft, account);
+                const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+                if (draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId]
+                    ?.accountIDs != null) {
+                    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs.filter((id) => id !== account.account_id);
+                }
+            }
+        },
+        excludeAccountFromReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        includeAccountInReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.includeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        includeAccountInReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { reconciliation, selectedPeriod } = action.payload;
+            if (reconciliation == null) {
+                return;
+            }
+            const accountId = reconciliation.account_id;
+            draft.excludedAccountIDs = draft.excludedAccountIDs.filter((id) => id !== accountId);
+            delete draft.excludedAccountExclusionInfo[accountId];
+            const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+            const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
+            if (accountReconciliationRecords != null) {
+                if (!accountReconciliationRecords.accountIDs.includes(accountId)) {
+                    accountReconciliationRecords.accountIDs.push(accountId);
+                }
+                // put this in a function
+                updateReconciliationByAccountIDOnIncludeAccount(draft, accountId, reconciliation, monthYearPeriodId);
+            }
+            draft.accountConnectionStatusByAccountID[accountId] = {
+                status: toBankStatusCodeType(reconciliation.bank_status.code),
+                connectionInProgress: false,
+                paymentAccountId: undefined,
+            };
+        },
+        includeAccountInReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        updateStatementUploadChosen: (draft, action) => {
+            draft.statementUploadChosen = action.payload.statementUploadChosen;
+        },
+        clearExpenseAutomationReconciliationView: (draft) => {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+// Export actions
+export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
+// Export reducer
+export default expenseAutomationReconciliationView.reducer;
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+    draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
+    draft.excludedAccountExclusionInfo = {};
+    excludedAccounts.forEach((ea) => {
+        const { exclusion_info } = ea;
+        draft.excludedAccountExclusionInfo[ea.account_id] = {
+            bankBalance: exclusion_info.bank_balance != null
+                ? {
+                    amount: exclusion_info.bank_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            clearedBalance: exclusion_info.cleared_balance != null
+                ? {
+                    amount: exclusion_info.cleared_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            variance: exclusion_info.variance != null
+                ? {
+                    amount: exclusion_info.variance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+        };
+    });
+    draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
+        accountIDs: [],
+        reconciliationByAccountID: {},
+    };
+    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)];
+    reconciliationData.forEach((reconciliation) => {
+        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: toBankStatusCodeType(reconciliation.bank_status.code),
+                connectionInProgress: false,
+                paymentAccountId: account?.payment_account_id ?? undefined,
+            };
+        }
+        else {
+            draft.accountConnectionStatusByAccountID[reconciliation.account_id] = {
+                status: toBankStatusCodeType(reconciliation.bank_status.code),
+                connectionInProgress: reconciliation.bank_status.code === 'not_connected' &&
+                    oldConnectionStatus.connectionInProgress === true,
+                paymentAccountId: account?.payment_account_id ?? undefined,
+            };
+        }
+        accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
+            accountId: reconciliation.account_id,
+            reconciliationId: reconciliation.reconciliation_id ?? undefined,
+            transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+            refreshStatus: { fetchState: 'Not-Started', error: undefined },
+            statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
+            statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
+            statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
+            statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+            localData: {
+                accountSource: account?.reconciliation_source != null
+                    ? toReconciliationAccountSource(account.reconciliation_source)
+                    : undefined,
+            },
+            accountDetectionReason: account?.detection_info != null && account.detection_reason != null
+                ? account.detection_reason
+                : 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) {
+    const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
+    const oldConnectionStatus = draft.accountConnectionStatusByAccountID[accountId];
+    draft.accountConnectionStatusByAccountID[accountId] = {
+        status: toBankStatusCodeType(reconciliationData.bank_status.code),
+        connectionInProgress: oldConnectionStatus != null
+            ? reconciliationData.bank_status.code === 'not_connected' &&
+                oldConnectionStatus.connectionInProgress === true
+            : false,
+        paymentAccountId: accounts.payment_account_id ?? undefined,
+    };
+    const oldStatementParseInProgress = oldRecord.statementParseInProgress;
+    const statementParseInProgress = reconciliationData.bank_status.code === 'parsing' ||
+        oldStatementParseInProgress === true;
+    if (refreshViewInBackground === true) {
+        draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId] = {
+            ...oldRecord,
+            reconciliationId: reconciliationData.reconciliation_id ?? undefined,
+            refreshStatus: { fetchState: 'Completed', error: undefined },
+            statementParseInProgress,
+        };
+    }
+    else {
+        draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId] = {
+            ...oldRecord,
+            statementParseInProgress,
+            reconciliationId: reconciliationData.reconciliation_id ?? undefined,
+            transactionFetchState: { fetchState: 'Completed', error: undefined },
+        };
+    }
+}
+const updateExcludedAccountExclusionInfo = (draft, account) => {
+    draft.excludedAccountExclusionInfo[account.account_id] = {
+        bankBalance: account.bank_balance != null
+            ? {
+                amount: account.bank_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        clearedBalance: account.cleared_balance != null
+            ? {
+                amount: account.cleared_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        variance: account.variance != null
+            ? {
+                amount: account.variance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+    };
+};
+const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, reconciliation, monthYearPeriodId) => {
+    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].reconciliationByAccountID[accountId] = {
+        accountId,
+        reconciliationId: reconciliation.reconciliation_id ?? undefined,
+        transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+        refreshStatus: { fetchState: 'Not-Started', error: undefined },
+        statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
+        statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+        localData: {},
+        accountDetectionReason: undefined,
+    };
+};
+//# sourceMappingURL=reconciliationViewReducer.js.map