@zeniai/client-epic-state 4.19.82 → 4.19.84-betaVR1

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/bulkUploadReceiptsEpic.js

@@ -0,0 +1,24 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { bulkUploadReceipts, bulkUploadReceiptsFailure, bulkUploadReceiptsSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const bulkUploadReceiptsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(bulkUploadReceipts.match), mergeMap((action) => {
+    const { files } = action.payload;
+    const formData = new FormData();
+    for (const file of files) {
+        formData.append('files', file, file.name);
+    }
+    return zeniAPI
+        .postFormData(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/receipts/bulk-upload`, formData)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(bulkUploadReceiptsSuccess({
+                batchId: response.data.batch_id,
+            }));
+        }
+        return of(bulkUploadReceiptsFailure({ error: response.status }));
+    }), catchError((error) => of(bulkUploadReceiptsFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Bulk upload receipts API call errored out: ' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/confirmBulkUploadMatchEpic.js

@@ -0,0 +1,49 @@
+import { from } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { confirmBulkUploadMatch, confirmBulkUploadMatchFailure, confirmBulkUploadMatchSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const confirmBulkUploadMatchEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(confirmBulkUploadMatch.match), exhaustMap((action) => {
+    const { batchId, attachmentId, transactionId, transactionType, fileName } = action.payload;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/receipts/manual-match`, {
+        attachment_id: attachmentId,
+        transaction_id: transactionId,
+        transaction_type: transactionType,
+        file_name: fileName,
+    })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return from([
+                confirmBulkUploadMatchSuccess({
+                    batchId,
+                    attachmentId,
+                    transactionId,
+                }),
+                openSnackbar({
+                    messageSection: 'receipt_match',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        return from([
+            confirmBulkUploadMatchFailure({ error: response.status }),
+            openSnackbar({
+                messageSection: 'receipt_match',
+                messageText: 'failed',
+                type: 'error',
+            }),
+        ]);
+    }), catchError((error) => from([
+        confirmBulkUploadMatchFailure({
+            error: createZeniAPIStatus('Unexpected Error', 'Confirm bulk upload match errored out: ' +
+                JSON.stringify(error)),
+        }),
+        openSnackbar({
+            messageSection: 'receipt_match',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/fetchBulkUploadBatchDetailsEpic.js

@@ -0,0 +1,40 @@
+import { EMPTY, from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { extractTransactionPayloadsFromBatchFiles, isBatchDetailsApiStatusCompleted, shouldFetchBatchDetailsForBatchId, toBatchDetails, } from '../../payload/missingReceiptsPayload';
+import { fetchBulkUploadBatchDetails, fetchBulkUploadBatchDetailsFailure, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatches, } from '../../reducers/missingReceiptsViewReducer';
+export const fetchBulkUploadBatchDetailsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchBulkUploadBatchDetails.match), mergeMap(() => {
+    const bulkUpload = state$.value.expenseAutomationMissingReceiptsViewState.bulkUpload;
+    const { currentBatchId } = bulkUpload;
+    if (currentBatchId == null) {
+        return of(fetchBulkUploadBatchDetailsFailure({
+            error: createZeniAPIStatus('Unexpected Error', 'No current batch ID available'),
+        }));
+    }
+    if (!shouldFetchBatchDetailsForBatchId(bulkUpload.batchStatusById, bulkUpload.batchListByPeriod, currentBatchId)) {
+        return EMPTY;
+    }
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/${currentBatchId}`)
+        .pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response) ||
+            response.data == null ||
+            !isBatchDetailsApiStatusCompleted(response.data.status)) {
+            if (isSuccessResponse(response) && response.data != null) {
+                return EMPTY;
+            }
+            return of(fetchBulkUploadBatchDetailsFailure({ error: response.status }));
+        }
+        const actions = [];
+        const transactionPayloads = extractTransactionPayloadsFromBatchFiles(response.data.files);
+        if (transactionPayloads.length > 0) {
+            actions.push(updateTransactions(transactionPayloads, (value) => value.transaction_id));
+        }
+        actions.push(fetchBulkUploadBatchDetailsSuccess(toBatchDetails(response.data, zeniAPI.apiEndPoints.fileMicroServiceBaseUrl)));
+        actions.push(fetchBulkUploadBatches(true));
+        return from(actions);
+    }), catchError((error) => of(fetchBulkUploadBatchDetailsFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch batch details errored out: ' + JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/fetchBulkUploadBatchesEpic.js

@@ -0,0 +1,47 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { convertToPeriod, toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { toBatchListItem, } from '../../payload/missingReceiptsPayload';
+import { fetchBulkUploadBatches, fetchBulkUploadBatchesFailure, fetchBulkUploadBatchesSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const fetchBulkUploadBatchesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchBulkUploadBatches.match), switchMap((action) => {
+    const { cacheOverride } = action.payload;
+    const state = state$.value;
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationMissingReceiptsViewState: { bulkUpload }, } = state;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const periodId = toMonthYearPeriodId(selectedPeriod);
+    const existingBatches = bulkUpload.batchListByPeriod[periodId] ?? [];
+    if (cacheOverride !== true && existingBatches.length > 0) {
+        return of(fetchBulkUploadBatchesSuccess({
+            batchList: existingBatches,
+            selectedPeriod,
+        }));
+    }
+    const period = convertToPeriod(selectedPeriod);
+    const queryParam = {
+        start_date: period.start,
+        end_date: period.end,
+        sort_order: 'desc',
+    };
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            /** Full list (all statuses) for UI; batch-details epics filter to `completed` only. */
+            return of(fetchBulkUploadBatchesSuccess({
+                batchList: response.data.batches.map(toBatchListItem),
+                selectedPeriod,
+            }));
+        }
+        return of(fetchBulkUploadBatchesFailure({
+            error: response.status,
+            selectedPeriod,
+        }));
+    }), catchError((error) => of(fetchBulkUploadBatchesFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch bulk upload batches errored out: ' +
+            JSON.stringify(error)),
+        selectedPeriod,
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/fetchCompletedTransactionsEpic.js

@@ -0,0 +1,61 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { convertToPeriod, toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchCompletedTransactions, fetchCompletedTransactionsFailure, fetchCompletedTransactionsSuccess, getCompletedTransactionsCacheKey, } from '../../reducers/missingReceiptsViewReducer';
+export const fetchCompletedTransactionsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchCompletedTransactions.match), switchMap((action) => {
+    const state = state$.value;
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationMissingReceiptsViewState: { bulkUpload }, } = state;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const periodId = toMonthYearPeriodId(selectedPeriod);
+    const isInitialLoad = action.payload.pageToken == null;
+    const cacheKey = getCompletedTransactionsCacheKey(periodId, bulkUpload.sortKey, bulkUpload.sortOrder, bulkUpload.completedSubTab);
+    const existingData = bulkUpload.completedTransactionsByPeriod[cacheKey];
+    if (isInitialLoad &&
+        action.payload.cacheOverride !== true &&
+        existingData != null &&
+        existingData.transactionIds.length > 0) {
+        return from([]);
+    }
+    const period = convertToPeriod(selectedPeriod);
+    const queryPayload = {
+        start_date: period.start,
+        end_date: period.end,
+        sort_by: bulkUpload.sortKey,
+        sort_order: bulkUpload.sortOrder === 'ascending' ? 'asc' : 'desc',
+        page_token: action.payload.pageToken ?? null,
+        page_size: 25,
+    };
+    if (bulkUpload.completedSubTab !== 'all') {
+        queryPayload.match_type = bulkUpload.completedSubTab;
+    }
+    const encodedQuery = encodeURIComponent(JSON.stringify(queryPayload));
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/receipt-agent/transactions/completed?query=${encodedQuery}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const transactionIds = response.data.transactions.map((t) => t.transaction_id);
+            const updateActions = [];
+            updateActions.push(updateTransactions(response.data.transactions, (value) => value.transaction_id));
+            updateActions.push(fetchCompletedTransactionsSuccess({
+                isInitialLoad,
+                transactionIds,
+                nextPageToken: response.data.next_page_token,
+                totalCount: response.data.total_count,
+                selectedPeriod,
+            }));
+            return from(updateActions);
+        }
+        return of(fetchCompletedTransactionsFailure({
+            error: response.status,
+            selectedPeriod,
+        }));
+    }), catchError((error) => of(fetchCompletedTransactionsFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch completed transactions errored: ' +
+            JSON.stringify(error)),
+        selectedPeriod,
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/fetchMoreBatchDetailsEpic.js

@@ -0,0 +1,34 @@
+import { concat, of } from 'rxjs';
+import { catchError, exhaustMap, filter } from 'rxjs/operators';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus } from '../../../../responsePayload';
+import { filterBatchListItemsForBatchDetailsFetch } from '../../payload/missingReceiptsPayload';
+import { fetchMoreBatchDetails, fetchMoreBatchDetailsComplete, fetchMoreBatchDetailsFailure, } from '../../reducers/missingReceiptsViewReducer';
+import { fetchBatchDetailsByIds } from './fetchMultipleBatchDetailsEpic';
+const MORE_BATCH_PAGE_SIZE = 1;
+export const fetchMoreBatchDetailsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchMoreBatchDetails.match), 
+/** One page at a time — avoids duplicate loads if IO + scroll fallback both fire. */
+exhaustMap(() => {
+    const state = state$.value;
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationMissingReceiptsViewState: { bulkUpload }, } = state;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    if (selectedPeriod == null) {
+        return of(fetchMoreBatchDetailsComplete());
+    }
+    const periodId = toMonthYearPeriodId(selectedPeriod);
+    const batchList = bulkUpload.batchListByPeriod[periodId] ?? [];
+    const failedIds = new Set(bulkUpload.failedBatchDetailIds);
+    const unfetchedBatches = filterBatchListItemsForBatchDetailsFetch(batchList).filter((batch) => bulkUpload.batchDetailsById[batch.batchId] == null &&
+        !failedIds.has(batch.batchId));
+    const unfetchedBatchIds = unfetchedBatches.map((batch) => batch.batchId);
+    if (unfetchedBatchIds.length === 0) {
+        return of(fetchMoreBatchDetailsComplete());
+    }
+    const nextPage = unfetchedBatchIds.slice(0, MORE_BATCH_PAGE_SIZE);
+    return concat(fetchBatchDetailsByIds(nextPage, zeniAPI), of(fetchMoreBatchDetailsComplete())).pipe(catchError((error) => of(fetchMoreBatchDetailsFailure({
+        error: createZeniAPIStatus('Unexpected Error', 'Fetch more batch details errored out: ' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/fetchMultipleBatchDetailsEpic.js

@@ -0,0 +1,57 @@
+import { EMPTY, concat, from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { extractTransactionPayloadsFromBatchFiles, filterBatchListItemsForBatchDetailsFetch, isBatchDetailsApiStatusCompleted, shouldFetchBatchDetailsForBatchId, toBatchDetails, } from '../../payload/missingReceiptsPayload';
+import { batchDetailFetchFailed, fetchBulkUploadBatchDetails, fetchBulkUploadBatchesSuccess, fetchMoreBatchDetailsComplete, setInitialBatchDetailsLoading, storeBatchDetails, } from '../../reducers/missingReceiptsViewReducer';
+const INITIAL_BATCH_PAGE_SIZE = 1;
+export function fetchBatchDetailsByIds(batchIds, zeniAPI) {
+    if (batchIds.length === 0) {
+        return EMPTY;
+    }
+    return from(batchIds).pipe(mergeMap((batchId) => zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/${batchId}`)
+        .pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response) ||
+            response.data == null ||
+            !isBatchDetailsApiStatusCompleted(response.data.status)) {
+            return EMPTY;
+        }
+        const actions = [];
+        const transactionPayloads = extractTransactionPayloadsFromBatchFiles(response.data.files);
+        if (transactionPayloads.length > 0) {
+            actions.push(updateTransactions(transactionPayloads, (value) => value.transaction_id));
+        }
+        actions.push(storeBatchDetails(toBatchDetails(response.data, zeniAPI.apiEndPoints.fileMicroServiceBaseUrl)));
+        return from(actions);
+    }), catchError((error) => {
+        console.error(`Failed to fetch batch details for ${batchId}:`, createZeniAPIStatus('Unexpected Error', 'Fetch batch details errored out: ' +
+            JSON.stringify(error)));
+        return of(batchDetailFetchFailed({ batchId }));
+    })), 5));
+}
+export const fetchMultipleBatchDetailsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchBulkUploadBatchesSuccess.match), mergeMap((action) => {
+    const batchList = action.payload.batchList;
+    const { batchDetailsById } = state$.value.expenseAutomationMissingReceiptsViewState.bulkUpload;
+    /** Only completed list rows may trigger batch-details API; preserve platform order. */
+    const completedBatchesMissingDetails = filterBatchListItemsForBatchDetailsFetch(batchList).filter((batch) => batchDetailsById[batch.batchId] == null);
+    const completedBatchIds = completedBatchesMissingDetails.map((batch) => batch.batchId);
+    const batchIdsToFetch = completedBatchIds.slice(0, INITIAL_BATCH_PAGE_SIZE);
+    if (batchIdsToFetch.length === 0) {
+        /**
+         * List refresh can complete while no row is `completed` yet (multi-fetch skips), or
+         * `currentBatchId` may not appear in the filtered list but still needs `GET /batches/:id`.
+         * Fall back to the single-batch-details epic so `phase` and details can resolve.
+         */
+        const bulkUpload = state$.value.expenseAutomationMissingReceiptsViewState.bulkUpload;
+        const currentId = bulkUpload.currentBatchId;
+        if (currentId != null &&
+            bulkUpload.phase === 'matching' &&
+            bulkUpload.batchDetailsById[currentId] == null &&
+            shouldFetchBatchDetailsForBatchId(bulkUpload.batchStatusById, bulkUpload.batchListByPeriod, currentId)) {
+            return of(fetchBulkUploadBatchDetails());
+        }
+        return EMPTY;
+    }
+    return concat(of(setInitialBatchDetailsLoading()), fetchBatchDetailsByIds(batchIdsToFetch, zeniAPI), of(fetchMoreBatchDetailsComplete()));
+}));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/searchTransactionsForManualMatchEpic.js

@@ -0,0 +1,68 @@
+import { from, merge, of } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { convertToPeriod } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { supportedTransactionPayloadToManualSearchResult } from '../../payload/missingReceiptsPayload';
+import { searchTransactionsForManualMatch, searchTransactionsForManualMatchFailure, searchTransactionsForManualMatchSuccess, } from '../../reducers/missingReceiptsViewReducer';
+import { toTransactionsSortKey } from '../../types/transactionsViewState';
+/**
+ * `auto_categorized` for manual transaction search (Unmatched).
+ * Backend contract TBD — align with `fetchTransactionCategorizationEpic` (`selectedTab === 'autoCategorized'`)
+ * when the expense-automation API documents the intended filter for this flow.
+ */
+export const MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED = false;
+export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI) => {
+    const searchActions$ = actions$.pipe(filter(searchTransactionsForManualMatch.match));
+    const pagination$ = searchActions$.pipe(filter((a) => a.payload.pageToken != null));
+    const newSearch$ = searchActions$.pipe(filter((a) => a.payload.pageToken == null), debounceTime(300));
+    return merge(pagination$, newSearch$).pipe(switchMap((action) => {
+        const { query, pageToken } = action.payload;
+        const state = state$.value;
+        const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationMissingReceiptsViewState: { bulkUpload: { manualSearch, sortKey, sortOrder }, }, } = state;
+        const currentTenant = getCurrentTenant(state);
+        const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+        if (selectedPeriod == null) {
+            return of(searchTransactionsForManualMatchFailure({
+                error: createZeniAPIStatus('Unexpected Error', 'Manual search requires a selected accounting period.'),
+            }));
+        }
+        const period = convertToPeriod(selectedPeriod);
+        const queryParam = {
+            start_date: period.start,
+            end_date: period.end,
+            auto_categorized: MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED,
+            sort_by: toTransactionsSortKey(sortKey),
+            sort_order: sortOrder === 'ascending' ? 'asc' : 'desc',
+            page_token: pageToken ?? null,
+            page_size: manualSearch.pageSize,
+            search_text: query,
+        };
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const { transactions, next_page_token, total_count } = response.data;
+                const append = pageToken != null;
+                const results = transactions.map(supportedTransactionPayloadToManualSearchResult);
+                const actionsOut = [
+                    updateTransactions(transactions, (value) => value.transaction_id, 'merge'),
+                    searchTransactionsForManualMatchSuccess({
+                        append,
+                        nextPageToken: next_page_token ?? null,
+                        results,
+                        totalCount: total_count,
+                    }),
+                ];
+                return from(actionsOut);
+            }
+            return of(searchTransactionsForManualMatchFailure({
+                error: response.status,
+            }));
+        }), catchError((error) => of(searchTransactionsForManualMatchFailure({
+            error: createZeniAPIStatus('Unexpected Error', 'Search transactions for manual match errored: ' +
+                JSON.stringify(error)),
+        }))));
+    }));
+};

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/uploadMissingReceiptSuccessEpic.js

@@ -12,11 +12,13 @@ export const uploadMissingReceiptSuccessEpic = (actions$, state$) => actions$.pi
     updateActions.push(updateTransaction(transactionPayload.transaction_id, transactionPayload, updateType));
     if (currentTenant != null) {
         const monthEndChecksPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
-        updateActions.push(fetchMonthEndCloseChecks({
-            tenantId: currentTenant.tenantId,
-            period: monthEndChecksPeriod,
-            refreshViewInBackground: true,
-        }));
+        if (monthEndChecksPeriod != null) {
+            updateActions.push(fetchMonthEndCloseChecks({
+                tenantId: currentTenant.tenantId,
+                period: monthEndChecksPeriod,
+                refreshViewInBackground: true,
+            }));
+        }
     }
     return from(updateActions);
 }));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/watchBulkUploadBatchStatusEpic.js

@@ -0,0 +1,42 @@
+import { EMPTY, from, merge, of, timer } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap, takeUntil, } from 'rxjs/operators';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { isSuccessResponse } from '../../../../responsePayload';
+import { extractTransactionPayloadsFromBatchFiles, isBatchDetailsApiStatusCompleted, toBatchDetails, } from '../../payload/missingReceiptsPayload';
+import { bulkUploadReceiptsSuccess, clearBulkUpload, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatches, pusherBatchStatusUpdate, requestMissingReceiptsTabNavigation, } from '../../reducers/missingReceiptsViewReducer';
+/** First poll after upload; then interval while batch not resolved via Pusher or API. */
+const FALLBACK_FIRST_DELAY_MS = 30000;
+const FALLBACK_POLL_INTERVAL_MS = 10000;
+/**
+ * On Pusher batch completion: refresh batch list (then fetchMultipleBatchDetailsEpic runs),
+ * and request switching to the Unmatched tab. Debounced to reduce duplicate refreshes.
+ */
+export const pusherBatchStatusCompletionEpic = (actions$) => actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((action) => action.payload.status === 'completed'), debounceTime(300), mergeMap(() => from([
+    fetchBulkUploadBatches({
+        cacheOverride: true,
+        invalidateBatchDetailsCache: true,
+    }),
+    requestMissingReceiptsTabNavigation({ tab: 'unmatched' }),
+])));
+export const pollBulkUploadBatchStatusEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(bulkUploadReceiptsSuccess.match), mergeMap((action) => {
+    const { batchId } = action.payload;
+    return timer(FALLBACK_FIRST_DELAY_MS, FALLBACK_POLL_INTERVAL_MS).pipe(takeUntil(merge(actions$.pipe(filter(clearBulkUpload.match)), actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((a) => a.payload.batchId === batchId)), actions$.pipe(filter(fetchBulkUploadBatchDetailsSuccess.match), filter((a) => a.payload.batchId === batchId)))), switchMap(() => zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/${batchId}`)
+        .pipe(mergeMap((response) => {
+        /** Same batch-details URL; polls until `status` is completed (Pusher may win first). */
+        if (isSuccessResponse(response) && response.data != null) {
+            if (isBatchDetailsApiStatusCompleted(response.data.status)) {
+                const actions = [];
+                const transactionPayloads = extractTransactionPayloadsFromBatchFiles(response.data.files);
+                if (transactionPayloads.length > 0) {
+                    actions.push(updateTransactions(transactionPayloads, (value) => value.transaction_id));
+                }
+                actions.push(fetchBulkUploadBatchDetailsSuccess(toBatchDetails(response.data, zeniAPI.apiEndPoints.fileMicroServiceBaseUrl)));
+                actions.push(fetchBulkUploadBatches(true));
+                actions.push(requestMissingReceiptsTabNavigation({ tab: 'unmatched' }));
+                return from(actions);
+            }
+        }
+        return EMPTY;
+    }), catchError(() => of()))));
+}));

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/uploadTransactionReceiptSuccessEpic.js

@@ -0,0 +1,24 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { fetchMonthEndCloseChecks } from '../../../monthEndCloseChecksView/monthEndCloseChecksViewReducer';
+import { uploadTransactionCategorizationReceiptSuccess } from '../../reducers/transactionsViewReducer';
+export const uploadTransactionReceiptSuccessEpic = (actions$, state$) => actions$.pipe(filter(uploadTransactionCategorizationReceiptSuccess.match), mergeMap((action) => {
+    const { transactionPayload, updateType } = action.payload;
+    const updateActions = [];
+    const currentTenant = getCurrentTenant(state$.value);
+    const selectedPeriodByTenantId = state$.value.expenseAutomationViewState.selectedPeriodByTenantId;
+    updateActions.push(updateTransaction(transactionPayload.transaction_id, transactionPayload, updateType));
+    if (currentTenant != null) {
+        const monthEndChecksPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+        if (monthEndChecksPeriod != null) {
+            updateActions.push(fetchMonthEndCloseChecks({
+                tenantId: currentTenant.tenantId,
+                period: monthEndChecksPeriod,
+                refreshViewInBackground: true,
+            }));
+        }
+    }
+    return from(updateActions);
+}));

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

@@ -1 +1,147 @@
-export {};
+import { toURL } from '../../../commonPayloadTypes/urlPayload';
+import { getTransactionPayloadAmount, } from '../../../entity/transaction/payloadTypes/transactionPayload';
+// -- Converter functions --
+export function toBatchFile(payload, filesEndPoint) {
+    return {
+        attachmentId: payload.attachment_id,
+        candidates: payload.candidates?.map((c) => ({
+            transactionId: c.transaction_id,
+            matchScore: c.match_score,
+        })),
+        fileDownloadUrl: payload.file_id != null && filesEndPoint != null
+            ? `${filesEndPoint}/1.0/files/${payload.file_id}?query=${encodeURIComponent(JSON.stringify({ download_file: true }))}`
+            : null,
+        fileId: payload.file_id,
+        filePreviewUrl: payload.file_preview_url,
+        filename: payload.filename,
+        matchSource: payload.match_source,
+        matchedTransactionId: payload.matched_transaction?.transaction_id,
+        status: payload.status,
+    };
+}
+export function extractTransactionPayloadsFromBatchFiles(files) {
+    const seen = new Set();
+    const payloads = [];
+    for (const file of files) {
+        if (file.matched_transaction != null) {
+            const id = file.matched_transaction.transaction_id;
+            if (!seen.has(id)) {
+                seen.add(id);
+                payloads.push(matchedTransactionPayloadToSupportedTransactionPayload(file.matched_transaction));
+            }
+        }
+        if (file.candidates != null) {
+            for (const candidate of file.candidates) {
+                const id = candidate.transaction_id;
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    payloads.push(matchedTransactionPayloadToSupportedTransactionPayload(candidate));
+                }
+            }
+        }
+    }
+    return payloads;
+}
+function matchedTransactionPayloadToSupportedTransactionPayload(payload) {
+    return {
+        transaction_id: payload.transaction_id,
+        transaction_type: payload.transaction_type ?? 'expense',
+        transaction_date: payload.transaction_date ?? '',
+        currency_code: payload.currency_code,
+        total_amount: payload.amount,
+        vendor_name: payload.vendor_name,
+        logo: payload.vendor_logo == null ? undefined : toURL(payload.vendor_logo),
+    };
+}
+export function toBatchSummary(payload) {
+    return {
+        failed: payload.failed,
+        matched: payload.matched,
+        noMatch: payload.no_match,
+        possibleMatches: payload.possible_matches,
+        total: payload.total,
+    };
+}
+export function toBatchDetails(payload, filesEndPoint) {
+    return {
+        batchId: payload.batch_id,
+        createdAt: payload.created_at,
+        files: payload.files.map((f) => toBatchFile(f, filesEndPoint)),
+        status: payload.status,
+        summary: toBatchSummary(payload.summary),
+    };
+}
+/** Batch list `status` is a string from the API — compare case-insensitively. */
+export function isBatchListStatusCompleted(status) {
+    return status.toLowerCase() === 'completed';
+}
+/**
+ * Subset of the get-all-batches (`/batches?query=...`) list that is eligible for
+ * `GET /batches/:batchId` details fetches. The stored list may include pending, failed, or other
+ * statuses for UI; only `completed` rows should trigger batch-details requests.
+ */
+export function filterBatchListItemsForBatchDetailsFetch(batches) {
+    return batches.filter((b) => isBatchListStatusCompleted(b.status));
+}
+/**
+ * Batch details API response `status` field — only completed payloads should be stored from
+ * multi-batch fetch paths (list can be briefly stale vs. live processing state).
+ */
+export function isBatchDetailsApiStatusCompleted(status) {
+    return status.toLowerCase() === 'completed';
+}
+export function findBatchListItemForBatchId(batchListByPeriod, batchId) {
+    for (const list of Object.values(batchListByPeriod)) {
+        const found = list.find((b) => b.batchId === batchId);
+        if (found != null) {
+            return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * Whether it is appropriate to call `GET .../batches/:id` for details.
+ * Skips when live batch status or batch list row indicates the batch is not completed yet.
+ * When status is unknown in both sources, allows the request (e.g. dispatch before list refresh).
+ */
+export function shouldFetchBatchDetailsForBatchId(batchStatusById, batchListByPeriod, batchId) {
+    const live = batchStatusById[batchId]?.status;
+    if (live === 'completed') {
+        return true;
+    }
+    if (live === 'pending' || live === 'processing') {
+        return false;
+    }
+    const listItem = findBatchListItemForBatchId(batchListByPeriod, batchId);
+    if (listItem != null && !isBatchListStatusCompleted(listItem.status)) {
+        return false;
+    }
+    return true;
+}
+export function toBatchListItem(payload) {
+    return {
+        batchId: payload.batch_id,
+        createdAt: payload.created_at,
+        failedCount: payload.failed_count,
+        matchedCount: payload.matched_count,
+        noMatchCount: payload.no_match_count,
+        possibleMatchesCount: payload.possible_matches_count,
+        status: payload.status,
+        totalFiles: payload.total_files,
+    };
+}
+/** Maps expense-automation transaction rows to manual-search list rows (Unmatched tab). */
+export function supportedTransactionPayloadToManualSearchResult(payload) {
+    const amountPayload = getTransactionPayloadAmount(payload);
+    return {
+        amount: amountPayload.amount,
+        currencyCode: amountPayload.currencyCode,
+        entityId: payload.vendor_id ?? payload.customer_id ?? '',
+        memo: payload.transaction_memo ?? '',
+        transactionDate: payload.transaction_date,
+        transactionId: payload.transaction_id,
+        transactionType: payload.transaction_type,
+        vendorName: payload.vendor_name ?? '',
+        vendorLogo: toURL(payload.logo)?.href,
+    };
+}