@zeniai/client-epic-state 5.1.18-betaDI11 → 5.1.18-betaDI12

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

@@ -67,3 +67,156 @@ function createReviewTransactionPayload(accountReconciliationEntity) {
     });
     return reviewTransactionsPayload;
 }
+export function isStatementDateConflictResponse(response) {
+    return response.status.code === 409 && response.error_code != null;
+}
+function transformStatementUploadPayloadToState(statementUploadPayload) {
+    return {
+        account: {
+            accountId: statementUploadPayload.account.account_id,
+            accountName: statementUploadPayload.account.account_name,
+            accountType: statementUploadPayload.account.account_type,
+            currencyCode: statementUploadPayload.account.currency_code,
+            last4Digits: statementUploadPayload.account.last_4_digits,
+        },
+        file: statementUploadPayload.file != null
+            ? {
+                fileId: statementUploadPayload.file.file_id,
+                fileName: statementUploadPayload.file.file_name,
+                signedUrl: statementUploadPayload.file.signed_url,
+            }
+            : null,
+        statementMeta: {
+            closingBalance: statementUploadPayload.statement_meta.closing_balance,
+            openingBalance: statementUploadPayload.statement_meta.opening_balance,
+            statementDataStatus: statementUploadPayload.statement_meta.statement_data_status,
+            statementEndDate: statementUploadPayload.statement_meta.statement_end_date,
+            statementStartDate: statementUploadPayload.statement_meta.statement_start_date,
+            statementStatus: statementUploadPayload.statement_meta.statement_status,
+            statementUploadId: statementUploadPayload.statement_meta.statement_upload_id,
+            totalDeposits: statementUploadPayload.statement_meta.total_deposits,
+            totalPayments: statementUploadPayload.statement_meta.total_payments,
+        },
+        statementTransactions: (statementUploadPayload.statement_transactions ?? []).map((txn) => ({
+            amount: txn.amount,
+            citations: (txn.citation ?? []).map((c) => ({
+                page: c.page,
+                pageHeight: c.page_height,
+                pageWidth: c.page_width,
+                polygon: (c.polygon ?? []).map((point) => ({
+                    x: point.x,
+                    y: point.y,
+                })),
+                referenceText: c.reference_text,
+            })),
+            isUserAdded: txn.is_user_added,
+            isUserEdited: txn.is_user_edited,
+            statementTransactionId: txn.statement_transaction_id,
+            transactionDate: txn.transaction_date,
+            transactionDirection: txn.transaction_direction,
+            transactionMemo: txn.transaction_memo,
+        })),
+        aiSummary: transformAiSummaryPayloadToState(statementUploadPayload.ai_summary),
+    };
+}
+function transformPreviousReconciliationInfoToState(payload) {
+    if (payload == null) {
+        return null;
+    }
+    return {
+        endDate: payload.end_date,
+        reconciledAt: payload.reconciled_at,
+        reconciledByUserId: payload.reconciled_by_user_id,
+        reconciliationId: payload.reconciliation_id,
+        startDate: payload.start_date,
+    };
+}
+function transformAiSummaryPayloadToState(aiSummaryPayload) {
+    if (aiSummaryPayload == null) {
+        return null;
+    }
+    const { chain_status: chainStatus } = aiSummaryPayload;
+    return {
+        accountIdentified: aiSummaryPayload.account_identified,
+        transactionsExtracted: aiSummaryPayload.transactions_extracted,
+        exceptionsDetected: aiSummaryPayload.exceptions_detected,
+        fieldsCaptured: (aiSummaryPayload.fields_captured ?? []).map((field) => ({
+            code: field.code,
+            label: field.label,
+        })),
+        chainStatus: {
+            code: chainStatus?.code ?? '',
+            label: chainStatus?.label ?? '',
+            expectedStartDate: chainStatus?.expected_start_date ?? null,
+            previousReconciliationInfo: transformPreviousReconciliationInfoToState(chainStatus?.previous_reconciliation_info),
+        },
+    };
+}
+/**
+ * Builds date-conflict state from a 409 Confirm & Save response.
+ * Returns null for non-409 responses or 409s without a recognized error code.
+ */
+export function transformStatementDateConflictToState(response) {
+    if (isStatementDateConflictResponse(response) === false) {
+        return null;
+    }
+    const previousReconciliationInfo = transformPreviousReconciliationInfoToState(response.previous_reconciliation_info);
+    if (response.error_code === 'STATEMENT_RANGE_ALREADY_RECONCILED' &&
+        previousReconciliationInfo == null) {
+        return null;
+    }
+    if (response.error_code === 'STATEMENT_RANGE_HAS_GAP' &&
+        response.expected_start_date == null &&
+        previousReconciliationInfo == null) {
+        return null;
+    }
+    return {
+        errorCode: response.error_code,
+        expectedStartDate: response.expected_start_date ?? null,
+        ...(previousReconciliationInfo != null ? { previousReconciliationInfo } : {}),
+    };
+}
+export function transformParseStatementPayloadToState(payload) {
+    return {
+        statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
+    };
+}
+export function transformUpdateStatementInfoPayloadToState(payload) {
+    return {
+        statementUpload: transformStatementUploadPayloadToState(payload.statement_upload),
+    };
+}
+export function transformStatementUpdateStateToPayload(localData) {
+    const { statementMeta, statementTransactions } = localData;
+    return {
+        statement_meta: {
+            opening_balance: statementMeta.openingBalance,
+            statement_end_date: statementMeta.statementEndDate,
+            statement_start_date: statementMeta.statementStartDate,
+            total_deposits: statementMeta.totalDeposits,
+            total_payments: statementMeta.totalPayments,
+        },
+        statement_transactions: {
+            added: statementTransactions.added.map((txn) => ({
+                amount: txn.amount,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+            deleted_ids: statementTransactions.deletedIds,
+            updated: statementTransactions.updated
+                .filter((txn) => txn.statementTransactionId != null)
+                .map((txn) => ({
+                amount: txn.amount,
+                statement_transaction_id: txn.statementTransactionId,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+        },
+    };
+}
+/** API request body for PUT statement-uploads; cast lives here for putAndGetJSON. */
+export function toStatementUpdateRequestBody(localData) {
+    return transformStatementUpdateStateToPayload(localData);
+}

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

@@ -1,6 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { defaultVendorCurrency } from '../../../entity/vendor/vendorState';
+import { date } from '../../../zeniDayJS';
 import { toBalancesByMonthFromPayload, toVendorFluxAnalysisStatusFromPayload, } from '../helpers/helpers';
 export const initialState = {
     fluxAnalysisEntities: { operatingExpenses: [] },
@@ -31,6 +32,7 @@ export const initialState = {
     fetchState: 'Not-Started',
     error: undefined,
     currency: defaultVendorCurrency,
+    lastRefreshSuccessTime: undefined,
     totalBalancesAndVariance: undefined,
     hasValidState() {
         return this.fetchState == 'Completed';
@@ -99,7 +101,7 @@ const expenseAutomationFluxAnalysisView = createSlice({
             },
         },
         fetchFluxAnalysisViewSuccess(draft, action) {
-            const { expensesPayload, selectedPeriod, keepExistingListItems, fetchReimbursement, currency, totalsPayload, } = action.payload;
+            const { expensesPayload, selectedPeriod, keepExistingListItems, fetchReimbursement, currency, status, totalsPayload, } = action.payload;
             const periodId = toMonthYearPeriodId(selectedPeriod);
             const group = draft.groupsBySelectedPeriod[periodId];
             const groupToBeFetched = fetchReimbursement
@@ -109,6 +111,9 @@ const expenseAutomationFluxAnalysisView = createSlice({
             // Handle fetch completion
             handleFetchCompletion(draft, selectedPeriod, fetchReimbursement, groupToBeFetched);
             draft.fetchState = 'Completed';
+            if (status?.last_refresh_success_time != null) {
+                draft.lastRefreshSuccessTime = date(status.last_refresh_success_time);
+            }
             // Update flux analysis entities
             const allFluxAnalysisEntities = updateFluxAnalysisEntities(draft.fluxAnalysisEntities, expensesPayload, currency);
             // Update operating expense ids based on the "keepExistingListItems" flag

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

@@ -2,6 +2,7 @@ import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { toReconciliationAccountSource } from '../../../entity/account/accountState';
 import { toBankStatusCodeType } from '../../../entity/accountRecon/accountReconState';
+import { toReconciliationViewSummary, } from '../types/reconciliationViewState';
 // Initial state
 export const initialReconciliationTabsState = {
     balances: {
@@ -67,6 +68,7 @@ export const initialState = {
     refreshStatus: { fetchState: 'Not-Started', error: undefined },
     actionFetchState: initialActionFetchState,
     selectedAccountId: undefined,
+    statementProcessingFailed: false,
     statementUploadChosen: false,
     reconListUIState: {
         nodeCollapseState: {},
@@ -75,6 +77,7 @@ export const initialState = {
         },
     },
     excludedAccountIDs: [],
+    summary: undefined,
 };
 // Create slice with reducers
 const expenseAutomationReconciliationView = createSlice({
@@ -143,7 +146,7 @@ const expenseAutomationReconciliationView = createSlice({
         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 ?? []);
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? [], action.payload.reconciliation.summary);
                 }
                 else if (action.payload.reconciliation.reconciliation.length > 0 &&
                     action.payload.reconciliation.accounts.length > 0) {
@@ -287,6 +290,10 @@ const expenseAutomationReconciliationView = createSlice({
         updateSelectedDrawerAccountId: (draft, action) => {
             draft.selectedDrawerAccountId = action.payload.selectedDrawerAccountId;
         },
+        updateStatementProcessingFailed: (draft, action) => {
+            draft.statementProcessingFailed =
+                action.payload.statementProcessingFailed;
+        },
         initialiseLocalDataForSelectedAccountId: () => { },
         updateSelectedTab: (draft, action) => {
             const { selectedTab } = action.payload;
@@ -378,10 +385,22 @@ const expenseAutomationReconciliationView = createSlice({
         },
         uploadAccountStatement: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
-                fetchState: 'In-Progress',
-                error: undefined,
-            };
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUploadStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.statementParseStatus = {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                };
+                accountRecon.reparseStatementStatus = {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                };
+            }
         },
         uploadAccountStatementSuccess: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
@@ -419,6 +438,143 @@ const expenseAutomationReconciliationView = createSlice({
                 error: action.payload.error,
             };
         },
+        parseStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.statementParseStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+        },
+        parseStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = false;
+            draft.statementProcessingFailed = false;
+        },
+        parseStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = false;
+            draft.statementProcessingFailed = true;
+        },
+        reparseStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.reparseStatementStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                accountRecon.statementParseStatus = {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                };
+                accountRecon.statementParseInProgress = false;
+            }
+        },
+        reparseStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseStatus = {
+                fetchState: 'Not-Started',
+                error: undefined,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = false;
+            draft.statementProcessingFailed = false;
+        },
+        reparseStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            draft.statementProcessingFailed = true;
+        },
+        resetReparseStatementStatus: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Not-Started',
+                error: undefined,
+            };
+        },
+        updateParsedStatementData: (draft, action) => {
+            const { accountId, selectedPeriod, parsedStatementData } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].parsedStatementData =
+                parsedStatementData;
+        },
+        updateStatementUpdateLocalData: (draft, action) => {
+            const { accountId, selectedPeriod, statementUpdateLocalData } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                if (accountRecon.localData == null) {
+                    accountRecon.localData = {
+                        statementUpdateLocalData,
+                    };
+                }
+                else {
+                    accountRecon.localData.statementUpdateLocalData =
+                        statementUpdateLocalData;
+                }
+            }
+        },
+        submitStatementUpdate: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                // Clear any stale date conflict from a previous attempt.
+                accountRecon.statementDateConflict = null;
+            }
+        },
+        submitStatementUpdateSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                accountRecon.statementDateConflict = null;
+                if (accountRecon.localData != null) {
+                    accountRecon.localData.statementUpdateLocalData = undefined;
+                }
+            }
+        },
+        submitStatementUpdateFailure: (draft, action) => {
+            const { accountId, selectedPeriod, dateConflict } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+                accountRecon.statementDateConflict = dateConflict ?? null;
+            }
+        },
+        clearStatementDateConflict: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementDateConflict = null;
+            }
+        },
         updateAccountReconciliationLocalData: (draft, action) => {
             const { accountId, selectedPeriod, localData } = action.payload;
             const oldLocalData = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData;
@@ -524,10 +680,10 @@ const expenseAutomationReconciliationView = createSlice({
     },
 });
 // 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 const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateStatementProcessingFailed, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, parseStatement, parseStatementSuccess, parseStatementFailure, reparseStatement, reparseStatementSuccess, reparseStatementFailure, resetReparseStatementStatus, updateParsedStatementData, updateStatementUpdateLocalData, submitStatementUpdate, submitStatementUpdateSuccess, submitStatementUpdateFailure, clearStatementDateConflict, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
 // Export reducer
 export default expenseAutomationReconciliationView.reducer;
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts, summary) {
     draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
     draft.excludedAccountExclusionInfo = {};
     excludedAccounts.forEach((ea) => {
@@ -556,6 +712,7 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                 : undefined,
         };
     });
+    const oldReconciliationByAccountID = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID ?? {};
     draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
         accountIDs: [],
         reconciliationByAccountID: {},
@@ -579,6 +736,7 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                 paymentAccountId: account?.payment_account_id ?? undefined,
             };
         }
+        const oldRecord = oldReconciliationByAccountID[reconciliation.account_id];
         accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
             accountId: reconciliation.account_id,
             reconciliationId: reconciliation.reconciliation_id ?? undefined,
@@ -586,16 +744,30 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
             refreshStatus: { fetchState: 'Not-Started', error: undefined },
             statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
             statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
-            statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
+            statementUpdateStatus: oldRecord?.statementUpdateStatus ?? {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
             statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+            statementParseStatus: oldRecord?.statementParseStatus ?? {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            reparseStatementStatus: oldRecord?.reparseStatementStatus ?? {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            statementDateConflict: oldRecord?.statementDateConflict ?? null,
             localData: {
+                ...oldRecord?.localData,
                 accountSource: account?.reconciliation_source != null
                     ? toReconciliationAccountSource(account.reconciliation_source)
-                    : undefined,
+                    : oldRecord?.localData?.accountSource,
             },
             accountDetectionReason: account?.detection_info != null && account.detection_reason != null
                 ? account.detection_reason
                 : undefined,
+            parsedStatementData: oldRecord?.parsedStatementData,
         };
         accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
     });
@@ -609,6 +781,10 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
         draft.fetchState = 'Completed';
         draft.error = undefined;
     }
+    if (summary !== undefined) {
+        draft.summary =
+            summary != null ? toReconciliationViewSummary(summary) : undefined;
+    }
 }
 function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
     const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
@@ -676,6 +852,9 @@ const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, recon
         statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
         statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
         statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+        statementParseStatus: { fetchState: 'Not-Started', error: undefined },
+        reparseStatementStatus: { fetchState: 'Not-Started', error: undefined },
+        statementDateConflict: null,
         localData: {},
         accountDetectionReason: undefined,
     };

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

@@ -153,27 +153,39 @@ const expenseAutomationTransactionsView = createSlice({
                     draft.transactionCategorizationView[selectedTab].fetchState =
                         'In-Progress';
                     draft.transactionCategorizationView[selectedTab].error = undefined;
+                    // A foreground fetch supersedes any in-flight background preload.
+                    // Reset refreshStatus so a cancelled preload doesn't leave the
+                    // spinner stuck at In-Progress.
+                    draft.transactionCategorizationView[selectedTab].refreshStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
                 }
                 draft.transactionCategorizationView[selectedTab].uiState.pageToken =
                     pageToken ?? null;
-                draft.transactionCategorizationView[selectedTab].uiState.searchString =
-                    searchString ?? '';
+                // Only overwrite when explicitly set; undefined means a non-search fetch
+                // (tab switch, period change) should preserve the existing search string.
+                if (searchString !== undefined) {
+                    draft.transactionCategorizationView[selectedTab].uiState.searchString =
+                        searchString;
+                }
                 draft.transactionCategorizationView[selectedTab].error = undefined;
+                const monthYearPeriod = {
+                    month: period.start.month,
+                    year: period.start.year,
+                };
+                const periodId = toMonthYearPeriodId(monthYearPeriod);
+                const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
+                    .transactionIdsBySelectedPeriod[periodId] ?? [];
                 // Reset list when we change the sort order and fetch list again
                 if (resetListItems === true) {
-                    const monthYearPeriod = {
-                        month: period.start.month,
-                        year: period.start.year,
-                    };
-                    const transactionIdsBySelectedPeriod = draft.transactionCategorizationView[selectedTab]
-                        .transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)];
                     transactionIdsBySelectedPeriod.forEach((transactionId) => {
                         delete draft.transactionCategorizationView[selectedTab]
                             .transactionReviewLocalDataById[transactionId];
                     });
                     draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds =
                         draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds.filter((selectedCheckBoxTransactionId) => transactionIdsBySelectedPeriod.includes(selectedCheckBoxTransactionId));
-                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)] = [];
+                    draft.transactionCategorizationView[selectedTab].transactionIdsBySelectedPeriod[periodId] = [];
                     draft.transactionCategorizationView[selectedTab].refreshStatus = {
                         fetchState: 'Not-Started',
                         error: undefined,
@@ -305,10 +317,12 @@ const expenseAutomationTransactionsView = createSlice({
             }
         },
         updateTransactionFilters(draft, action) {
-            const { selectedTab, filters } = action.payload;
-            // `filters` is non-nullable per the payload type, so no runtime
-            // null-check is needed — dropping it removes a dead defensive branch.
-            draft.transactionCategorizationView[selectedTab].filters = filters;
+            const { filters } = action.payload;
+            // Filters are tab-agnostic (payee/category/class/amount), so apply to
+            // all tabs so switching tabs after filtering shows consistent results.
+            TRANSACTIONS_TABS.forEach((tab) => {
+                draft.transactionCategorizationView[tab].filters = filters;
+            });
         },
         saveTransactionCategorization: {
             prepare(selectedTab, transactionIds, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled) {
@@ -660,18 +674,24 @@ const expenseAutomationTransactionsView = createSlice({
         resetOtherTabsFetchState(draft, action) {
             const { tabs, refreshViewInBackground } = action.payload;
             tabs.forEach((tab) => {
-                if (draft.transactionCategorizationView[tab].fetchState ===
-                    'In-Progress' ||
-                    refreshViewInBackground !== true) {
+                const tabFetchState = draft.transactionCategorizationView[tab].fetchState;
+                if (refreshViewInBackground !== true) {
+                    // Foreground fetch completed: mark other tabs as Completed.
                     draft.transactionCategorizationView[tab].fetchState = 'Completed';
                     draft.transactionCategorizationView[tab].error = undefined;
                 }
-                else {
+                else if (tabFetchState !== 'In-Progress') {
+                    // Background fetch completed: reset the other tab's refreshStatus,
+                    // but only when it is not mid-load. During a dual-search the active
+                    // tab has its own foreground fetch in flight — clobbering its
+                    // fetchState here would drop the skeleton and show an empty list.
                     draft.transactionCategorizationView[tab].refreshStatus = {
                         fetchState: 'Not-Started',
                         error: undefined,
                     };
                 }
+                // If tabFetchState === 'In-Progress' and refreshViewInBackground === true,
+                // leave the other tab's state untouched — it has its own active fetch.
             });
         },
         fetchTransactionCategorizationFailure(draft, action) {

package/lib/esm/view/expenseAutomationView/selectors/fluxAnalysisViewSelector.js

@@ -8,7 +8,7 @@ import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationFluxAnalysisView(state) {
     const { expenseAutomationFluxAnalysisViewState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { fetchState, error, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
+    const { fetchState, error, lastRefreshSuccessTime, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
     const fetchStateAndError = {
         fetchState,
         error,
@@ -110,6 +110,7 @@ export function getExpenseAutomationFluxAnalysisView(state) {
         refreshStatus,
         currency,
         completionStatus,
+        lastRefreshSuccessTime,
     };
 }
 // Helper function to transform operating expense to vendor view