@zeniai/client-epic-state 4.20.7 → 4.20.9-beta0ND

package/lib/esm/reducer.js

@@ -58,6 +58,7 @@ import toastNotification, { initialState as initialToastNotificationState, } fro
 import transaction, { initialState as initialTransactionState, } from './entity/transaction/transactionReducer';
 import transactionActivityLog, { initialState as initialTransactionActivityLogState, } from './entity/transactionActivityLog/transactionActivityLogReducer';
 import user, { initialState as initialUserState, } from './entity/user/userReducer';
+import userGroups, { initialState as initialUserGroupsState, } from './entity/userGroups/userGroupsReducer';
 import userRole, { initialState as initialUserRoleState, } from './entity/userRole/userRoleReducer';
 import vendor, { initialState as initialVendorState, } from './entity/vendor/vendorReducer';
 import vendorExpense, { initialState as initialVendorExpenseState, } from './entity/vendorExpense/vendorExpenseReducer';
@@ -198,6 +199,7 @@ import trend, { initialTrendState } from './view/trend/trendReducer';
 import trendWithTransactions, { initialTrendWithTransactionsState, } from './view/trendWithTransactions/trendWithTransactionsReducer';
 import twoFactorAuthentication, { initialState as initialTwoFactorAuthenticationState, } from './view/twoFactorAuthentication/twoFactorAuthenticationReducer';
 import userFinancialAccountState, { initialState as initialUserFinancialAccountState, } from './view/userFinancialAccount/userFinancialAccountReducer';
+import userGroupListView, { initialState as initialUserGroupListViewState, } from './view/userGroupListView/userGroupListViewReducer';
 import userListView, { initialState as initialUserListViewState, } from './view/userListView/userListViewReducer';
 import userRoleConfig, { initialState as initialUserRoleConfigState, } from './view/userRoleConfigView/userRoleConfigReducer';
 import vendor1099TypeList, { initialState as initialVendor1099TypeListState, } from './view/vendor1099TypeList/vendor1099TypeListReducer';
@@ -270,6 +272,7 @@ const initialEntitiesState = {
     toastNotificationState: initialToastNotificationState,
     transactionActivityLogState: initialTransactionActivityLogState,
     transactionState: initialTransactionState,
+    userGroupsState: initialUserGroupsState,
     userRoleState: initialUserRoleState,
     userState: initialUserState,
     vendorExpenseState: initialVendorExpenseState,
@@ -408,6 +411,7 @@ const initialViewsState = {
     trendWithTransactionsState: initialTrendWithTransactionsState,
     twoFactorAuthenticationState: initialTwoFactorAuthenticationState,
     userFinancialAccountState: initialUserFinancialAccountState,
+    userGroupListViewState: initialUserGroupListViewState,
     userListViewState: initialUserListViewState,
     userRoleConfigState: initialUserRoleConfigState,
     vendorFirstReviewViewState: initialVendorFirstReviewViewState,
@@ -492,6 +496,7 @@ const entityReducers = {
     toastNotificationState: toastNotification,
     transactionActivityLogState: transactionActivityLog,
     transactionState: transaction,
+    userGroupsState: userGroups,
     userRoleState: userRole,
     userState: user,
     vendorExpenseState: vendorExpense,
@@ -630,6 +635,7 @@ const viewReducers = {
     trendWithTransactionsState: trendWithTransactions,
     twoFactorAuthenticationState: twoFactorAuthentication,
     userFinancialAccountState: userFinancialAccountState,
+    userGroupListViewState: userGroupListView,
     userListViewState: userListView,
     userRoleConfigState: userRoleConfig,
     vendorFirstReviewViewState: vendorFirstReviewView,

package/lib/esm/view/arAgingView/arAgingReport/arAgingReducer.js

@@ -1,9 +1,9 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { mapReportPayloadV2ToReportV2 } from '../../../commonPayloadTypes/v2/viewAndReportPayloadv2';
 import { getAgingBalancesKey, toAgingPeriod, } from '../../../commonStateTypes/agingBalance/agingBalance';
+import { defaultCustomerCurrency } from '../../../commonStateTypes/currencyHelper';
 import { getNestedCustomerHierarchy } from '../../../commonStateTypes/customerView/getNestedCustomerHierarchy';
 import { toCustomer } from '../../../entity/customer/customerPayload';
-import { defaultCustomerCurrency } from '../../../entity/customer/customerState';
 import { dateNow } from '../../../zeniDayJS';
 import { toArAgingDataByCustomerId, toArAgingTotals, } from './arAgingPayload';
 export const inititalUIState = {

package/lib/esm/view/arAgingView/arAgingReport/arAgingSelector.js

@@ -1,8 +1,8 @@
 import { createSelector } from '@reduxjs/toolkit';
 import orderBy from 'lodash/orderBy';
 import { getAgingBalancesKey, } from '../../../commonStateTypes/agingBalance/agingBalance';
+import { defaultCustomerCurrency } from '../../../commonStateTypes/currencyHelper';
 import { getCustomer } from '../../../entity/customer/customerSelector';
-import { defaultCustomerCurrency, } from '../../../entity/customer/customerState';
 export const getArAgingReport = createSelector((state) => state.arAgingState, (state) => state.customerState, (arAgingState, customerState) => {
     const { reportId, reportTitle, fetchState, uiState, firstMonthOfFY, agingPeriods, } = arAgingState;
     const { searchString, sortOrder, sortKey, selectedDate } = uiState;

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

@@ -0,0 +1,33 @@
+import { merge, of } from 'rxjs';
+import { filter, mergeMap, switchMap, take, takeUntil } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { bulkUploadReceiptsSuccess, clearBulkUpload, fetchBulkUploadBatchDetailsSuccess, restoreBulkUploadMatchingState, storeBatchDetails, } from '../../reducers/missingReceiptsViewReducer';
+/**
+ * Show a success toast when batch details arrive for the current upload batch,
+ * e.g. "17 out of 20 Receipts Matched". Scoped per upload session so it fires
+ * only once: starts on `bulkUploadReceiptsSuccess` (or `restoreBulkUploadMatchingState`
+ * for a restored session), waits for the first batch-details action for that batch,
+ * emits the toast, then stops. `clearBulkUpload` cancels the in-flight wait.
+ */
+export const bulkUploadMatchResultToastEpic = (actions$) => actions$.pipe(filter((action) => bulkUploadReceiptsSuccess.match(action) ||
+    restoreBulkUploadMatchingState.match(action)), switchMap((uploadAction) => {
+    const { batchId } = uploadAction.payload;
+    return merge(actions$.pipe(filter(fetchBulkUploadBatchDetailsSuccess.match)), actions$.pipe(filter(storeBatchDetails.match))).pipe(filter((a) => a.payload.batchId === batchId), take(1), mergeMap((action) => {
+        const { summary } = action.payload;
+        return of(openSnackbar({
+            messageSection: 'receipts_bulk_match',
+            messageText: 'success',
+            type: 'success',
+            variables: [
+                {
+                    variableName: '_matched_',
+                    variableValue: String(summary.matched),
+                },
+                {
+                    variableName: '_total_',
+                    variableValue: String(summary.total),
+                },
+            ],
+        }));
+    }), takeUntil(actions$.pipe(filter(clearBulkUpload.match))));
+}));

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

@@ -0,0 +1,29 @@
+import { concat, of, timer } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { BULK_UPLOAD_BAR_COMPLETE_HOLD_MS } from '../../helpers/bulkUploadTiming';
+import { bulkUploadReceipts, bulkUploadReceiptsFailure, bulkUploadReceiptsSuccess, updateBulkUploadProgress, } 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) {
+            const batchId = String(response.data.batch_id ?? '').trim();
+            if (batchId === '') {
+                return of(bulkUploadReceiptsFailure({
+                    error: createZeniAPIStatus('Unexpected Error', 'Bulk upload succeeded but batch_id was missing or empty.'),
+                }));
+            }
+            return concat(of(updateBulkUploadProgress(100)), timer(BULK_UPLOAD_BAR_COMPLETE_HOLD_MS).pipe(mergeMap(() => of(bulkUploadReceiptsSuccess({ batchId })))));
+        }
+        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({ cacheOverride: 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,49 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { 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';
+import { BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS } from '../../helpers/bulkUploadTiming';
+import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
+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 { end, start } = rollingCalendarDateRangeInclusive(BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS);
+    const queryParam = {
+        start_date: start,
+        end_date: 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,33 @@
+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 = 5;
+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,56 @@
+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 = 5;
+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/refetchCompletedTransactionsOnBulkUploadSortEpic.js

@@ -0,0 +1,12 @@
+import { of } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { fetchCompletedTransactions, setBulkUploadCompletedSubTab, setBulkUploadSortConfig, } from '../../reducers/missingReceiptsViewReducer';
+/**
+ * Completed transactions are cached per sort key/order/sub-tab. After a sort or sub-tab
+ * change, the fetch epic would otherwise skip the network when that cache entry already
+ * exists — dispatch a cache-bypassing initial fetch whenever either changes from the UI.
+ */
+export const refetchCompletedTransactionsOnBulkUploadSortEpic = (actions$) => {
+    return actions$.pipe(filter((action) => setBulkUploadSortConfig.match(action) ||
+        setBulkUploadCompletedSubTab.match(action)), mergeMap(() => of(fetchCompletedTransactions(undefined, true))));
+};

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

@@ -0,0 +1,98 @@
+import { EMPTY, concat, from, of } from 'rxjs';
+import { catchError, concatMap, filter, mergeMap, take } from 'rxjs/operators';
+import { isSuccessResponse } from '../../../../responsePayload';
+import { isBatchDetailsStatusPendingOrProcessing, toBatchListItem, } from '../../payload/missingReceiptsPayload';
+import { fetchBulkUploadBatchesSuccess, restoreBulkUploadAutomatchingOnMount, restoreBulkUploadMatchingState, } from '../../reducers/missingReceiptsViewReducer';
+import { BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS } from '../../helpers/bulkUploadTiming';
+import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+/**
+ * On missing-receipts entry / period switch, hydrate the automatching banner for the logged-in
+ * user without relying on UI-driven list fetches (the Missing tab does not fetch the batch list
+ * while `phase === 'idle'`). Flow:
+ *  1. Call `GET /1.0/batches` (rolling 30-day window).
+ *  2. Emit `fetchBulkUploadBatchesSuccess` so `batchListByPeriod` is populated for the selected
+ *     period (prevents a duplicate list fetch when the user switches to the Unmatched tab).
+ *  3. For each `processing|pending` row, call `GET /1.0/batches/:id` in order; for the first row
+ *     whose details `user_id` matches the logged-in user and whose status is still
+ *     pending/processing, dispatch `restoreBulkUploadMatchingState` and stop.
+ */
+export const restoreBulkUploadAutomatchingOnMountEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(restoreBulkUploadAutomatchingOnMount.match), mergeMap(() => {
+    const state = state$.value;
+    const { expenseAutomationMissingReceiptsViewState: { bulkUpload }, expenseAutomationViewState: { selectedPeriodByTenantId }, } = state;
+    if (bulkUpload.phase !== 'idle') {
+        return EMPTY;
+    }
+    if (bulkUpload.batchListFetchState.fetchState === 'In-Progress') {
+        return EMPTY;
+    }
+    const loggedInUserId = state.tenantState.loggedInUser?.userId;
+    if (loggedInUserId == null) {
+        return EMPTY;
+    }
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    if (selectedPeriod == null) {
+        return EMPTY;
+    }
+    const { end, start } = rollingCalendarDateRangeInclusive(BULK_UPLOAD_BATCH_LIST_DATE_RANGE_DAYS);
+    const queryParam = {
+        start_date: start,
+        end_date: end,
+        sort_order: 'desc',
+    };
+    const listUrl = `${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches?query=${encodeURIComponent(JSON.stringify(queryParam))}`;
+    const detailsBaseUrl = `${zeniAPI.apiEndPoints.communicationAgentMicroServiceBaseUrl}/1.0/batches/`;
+    const periodId = toMonthYearPeriodId(selectedPeriod);
+    const alreadyCached = (bulkUpload.batchListByPeriod[periodId] ?? []).length > 0 &&
+        bulkUpload.batchListFetchState.fetchState === 'Completed';
+    const listSource = alreadyCached
+        ? of(null)
+        : zeniAPI.getJSON(listUrl).pipe(catchError(() => of(null)));
+    return listSource.pipe(mergeMap((listResponse) => {
+        const batchList = alreadyCached
+            ? bulkUpload.batchListByPeriod[periodId] ?? []
+            : listResponse != null &&
+                isSuccessResponse(listResponse) &&
+                listResponse.data != null
+                ? listResponse.data.batches.map(toBatchListItem)
+                : null;
+        if (batchList == null) {
+            return EMPTY;
+        }
+        const successAction = alreadyCached
+            ? null
+            : fetchBulkUploadBatchesSuccess({
+                batchList,
+                selectedPeriod,
+            });
+        const processingBatches = batchList.filter((b) => {
+            const status = b.status.toLowerCase();
+            return status === 'processing' || status === 'pending';
+        });
+        const restoreStream = from(processingBatches).pipe(concatMap((batch) => zeniAPI
+            .getJSON(`${detailsBaseUrl}${batch.batchId}`)
+            .pipe(mergeMap((response) => {
+            if (!isSuccessResponse(response) || response.data == null) {
+                return EMPTY;
+            }
+            const data = response.data;
+            const detailsUserId = data.user_id;
+            if (detailsUserId == null ||
+                detailsUserId !== loggedInUserId) {
+                return EMPTY;
+            }
+            if (!isBatchDetailsStatusPendingOrProcessing(data.status)) {
+                return EMPTY;
+            }
+            return of(restoreBulkUploadMatchingState({
+                batchId: batch.batchId,
+                totalFiles: batch.totalFiles,
+            }));
+        }), catchError(() => EMPTY))), take(1));
+        return successAction != null
+            ? concat(of(successAction), restoreStream)
+            : restoreStream;
+    }));
+}));

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

@@ -0,0 +1,71 @@
+import { EMPTY, from, merge, of } from 'rxjs';
+import { catchError, debounceTime, filter, mergeMap, switchMap, } from 'rxjs/operators';
+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';
+import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
+/**
+ * `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;
+/** Inclusive rolling window for manual match search (ignores accounting period picker). */
+const MANUAL_SEARCH_TRANSACTION_DATE_RANGE_DAYS = 90;
+export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI) => {
+    const searchActions$ = actions$.pipe(filter(searchTransactionsForManualMatch.match));
+    const pagination$ = searchActions$.pipe(filter((action) => action.payload.pageToken != null));
+    /**
+     * No API for empty or 1-char queries; immediate merge so switchMap cancels any in-flight HTTP.
+     */
+    const newSearchTooShortOrClear$ = searchActions$.pipe(filter((action) => action.payload.pageToken == null &&
+        action.payload.query.trim().length < 2));
+    const newSearchDebounced$ = searchActions$.pipe(filter((action) => action.payload.pageToken == null &&
+        action.payload.query.trim().length >= 2), debounceTime(300));
+    return merge(pagination$, newSearchTooShortOrClear$, newSearchDebounced$).pipe(switchMap((action) => {
+        const { query, pageToken } = action.payload;
+        if (pageToken == null && query.trim().length < 2) {
+            return EMPTY;
+        }
+        const state = state$.value;
+        const { expenseAutomationMissingReceiptsViewState: { bulkUpload: { manualSearch, sortKey, sortOrder }, }, } = state;
+        const { end, start } = rollingCalendarDateRangeInclusive(MANUAL_SEARCH_TRANSACTION_DATE_RANGE_DAYS);
+        const queryParam = {
+            start_date: start,
+            end_date: 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);
 }));