@zeniai/client-epic-state 4.19.37-betaAS2 → 4.19.37-betaVR1

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

@@ -0,0 +1,48 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { convertToPeriod } from '../../../../commonStateTypes/timePeriod';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { completedTransactionPayloadToSupportedTransactionPayload, } from '../../payload/missingReceiptsPayload';
+import { fetchCompletedTransactions, fetchCompletedTransactionsFailure, fetchCompletedTransactionsSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const fetchCompletedTransactionsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchCompletedTransactions.match), switchMap((action) => {
+    const state = state$.value;
+    const { expenseAutomationMissingReceiptsViewState: { bulkUpload }, } = state;
+    const { selectedPeriod } = action.payload;
+    const queryPayload = {};
+    if (bulkUpload.completedSubTab !== 'all') {
+        queryPayload.match_type = bulkUpload.completedSubTab;
+    }
+    const period = convertToPeriod(selectedPeriod);
+    queryPayload.start_date = period.start;
+    queryPayload.end_date = period.end;
+    if (action.payload.pageToken != null) {
+        queryPayload.page_token = action.payload.pageToken;
+    }
+    const encodedQuery = encodeURIComponent(JSON.stringify(queryPayload));
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/receipt-agent/transactions/completed?query=${encodedQuery}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const transactionPayloads = response.data.transactions.map(completedTransactionPayloadToSupportedTransactionPayload);
+            const transactionIds = response.data.transactions.map((t) => t.transaction_id);
+            const updateActions = [];
+            updateActions.push(updateTransactions(transactionPayloads, (value) => value.transaction_id));
+            updateActions.push(fetchCompletedTransactionsSuccess({
+                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/searchTransactionsForManualMatchEpic.js

@@ -0,0 +1,27 @@
+import { of } from 'rxjs';
+import { catchError, debounceTime, filter, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { toManualSearchResult, } from '../../payload/missingReceiptsPayload';
+import { searchTransactionsForManualMatch, searchTransactionsForManualMatchFailure, searchTransactionsForManualMatchSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const searchTransactionsForManualMatchEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(searchTransactionsForManualMatch.match), debounceTime(300), switchMap((action) => {
+    const { query } = action.payload;
+    const searchQuery = JSON.stringify({
+        search_text: query,
+        search_fields: ['date', 'amount', 'vendor_name'],
+    });
+    const encodedQuery = encodeURIComponent(searchQuery);
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.searchMicroServiceBaseUrl}/1.0/transaction-search?query=${encodedQuery}`)
+        .pipe(switchMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const results = response.data.transactions.map(toManualSearchResult);
+            return of(searchTransactionsForManualMatchSuccess(results));
+        }
+        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/watchBulkUploadBatchStatusEpic.js

@@ -0,0 +1,41 @@
+import { of, timer } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap, takeUntil, takeWhile, } from 'rxjs/operators';
+import { isSuccessResponse } from '../../../../responsePayload';
+import { toBatchStatus, } from '../../payload/missingReceiptsPayload';
+import { bulkUploadReceiptsSuccess, clearBulkUpload, fetchBulkUploadBatchDetails, pusherBatchStatusUpdate, updateBulkUploadBatchStatus, } from '../../reducers/missingReceiptsViewReducer';
+/**
+ * Watches batch status using two strategies:
+ * 1. Pusher (primary): Reacts to `pusherBatchStatusUpdate` dispatched by the UI layer
+ *    when a Pusher event arrives. Immediately fetches full details on completion.
+ * 2. Polling (fallback): Starts a relaxed 10s poll after upload success as a safety net
+ *    in case the Pusher event is missed. Stops on completion or `clearBulkUpload`.
+ */
+// Pusher-driven: when Pusher delivers a completed status, fetch details
+export const pusherBatchStatusCompletionEpic = (actions$) => actions$.pipe(filter(pusherBatchStatusUpdate.match), filter((action) => action.payload.status === 'completed'), mergeMap(() => of(fetchBulkUploadBatchDetails())));
+// Polling fallback: relaxed interval as safety net
+const FALLBACK_POLL_INTERVAL_MS = 10000;
+export const pollBulkUploadBatchStatusEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(bulkUploadReceiptsSuccess.match), switchMap((action) => {
+    const { batchId } = action.payload;
+    return timer(0, FALLBACK_POLL_INTERVAL_MS).pipe(takeUntil(actions$.pipe(filter((a) => clearBulkUpload.match(a) ||
+        (pusherBatchStatusUpdate.match(a) &&
+            a.payload.status === 'completed')))), switchMap(() => zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/receipts/batches/${batchId}/status`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const batchStatus = toBatchStatus(response.data);
+            const actions = [
+                updateBulkUploadBatchStatus(batchStatus),
+            ];
+            if (batchStatus.status === 'completed') {
+                actions.push(fetchBulkUploadBatchDetails());
+            }
+            return actions;
+        }
+        return [];
+    }), catchError(() => of()))), takeWhile((action) => {
+        if (fetchBulkUploadBatchDetails.match(action)) {
+            return false;
+        }
+        return true;
+    }, true));
+}));

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

@@ -1 +1,164 @@
-export {};
+// -- Converter functions --
+export function toBatchFile(payload) {
+    return {
+        attachmentId: payload.attachment_id,
+        candidates: payload.candidates?.map((c) => ({
+            transactionId: c.transaction_id,
+            matchScore: c.match_score,
+        })),
+        fileId: payload.file_id,
+        filePreviewUrl: payload.file_preview_url,
+        filename: payload.filename,
+        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_date: payload.transaction_date,
+        currency_code: payload.currency_code,
+        total_amount: payload.amount,
+        vendor_name: payload.vendor_name,
+    };
+}
+export function toBatchSummary(payload) {
+    return {
+        failed: payload.failed,
+        matched: payload.matched,
+        noMatch: payload.no_match,
+        possibleMatches: payload.possible_matches,
+        total: payload.total,
+    };
+}
+export function toBatchStatus(payload) {
+    return {
+        batchId: payload.batch_id,
+        progress: payload.progress,
+        status: payload.status,
+    };
+}
+export function toBatchDetails(payload) {
+    return {
+        batchId: payload.batch_id,
+        createdAt: payload.created_at,
+        files: payload.files.map(toBatchFile),
+        status: payload.status,
+        summary: toBatchSummary(payload.summary),
+    };
+}
+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,
+    };
+}
+export function toManualSearchResult(payload) {
+    return {
+        amount: payload.amount,
+        currency: payload.currency,
+        entityId: payload.entity_id,
+        memo: payload.memo,
+        transactionDate: payload.transaction_date,
+        transactionId: payload.transaction_id,
+        transactionType: payload.transaction_type,
+        vendorName: payload.vendor_name,
+    };
+}
+function completedTransactionAttachmentToAttachmentPayload(payload) {
+    return {
+        attachment_create_time: payload.attachment_create_time ?? '',
+        attachment_id: payload.attachment_id,
+        attachment_update_time: payload.attachment_update_time ?? '',
+        content_type: payload.content_type,
+        file_checksum: null,
+        file_download_url: payload.file_download_url,
+        file_name: payload.file_name,
+        file_size: payload.file_size,
+    };
+}
+function completedTransactionLineToLinePayload(payload) {
+    return {
+        amount: payload.amount,
+        line_description: payload.line_description,
+        line_detail_type: payload.line_detail_type,
+        line_id: payload.line_id,
+        categorization_status: payload.categorization_status,
+        line_detail: {
+            account: {
+                account_id: payload.line_detail.account?.account_id ?? '',
+                account_name: payload.line_detail.account?.account_name ?? '',
+                labels: [],
+                coa_id: payload.line_detail.account?.coa_id,
+                qbo_id: payload.line_detail.account?.qbo_id,
+            },
+            class: {
+                accounting_class_id: payload.line_detail.class?.accounting_class_id ?? '',
+                accounting_class_name: payload.line_detail.class?.accounting_class_name ?? '',
+                accounting_class_number: payload.line_detail.class?.accounting_class_number,
+                fully_qualified_accounting_class_name: payload.line_detail.class?.fully_qualified_accounting_class_name,
+                qbo_id: payload.line_detail.class?.qbo_id,
+            },
+            line_detail_type: payload.line_detail_type,
+            customer: payload.line_detail.customer != null
+                ? {
+                    customer_id: payload.line_detail.customer.customer_id,
+                    customer_name: payload.line_detail.customer.customer_name,
+                    qbo_id: payload.line_detail.customer.qbo_id,
+                }
+                : undefined,
+            vendor: payload.line_detail.vendor != null
+                ? {
+                    vendor_id: payload.line_detail.vendor.vendor_id,
+                    vendor_name: payload.line_detail.vendor.vendor_name,
+                }
+                : undefined,
+        },
+    };
+}
+export function completedTransactionPayloadToSupportedTransactionPayload(payload) {
+    return {
+        transaction_id: payload.transaction_id,
+        transaction_type: payload.transaction_type,
+        transaction_date: payload.transaction_date,
+        transaction_type_name: payload.transaction_type_name,
+        currency_code: payload.currency_code,
+        currency_symbol: payload.currency_symbol,
+        total_amount: payload.total_amount,
+        vendor_id: payload.vendor_id,
+        vendor_name: payload.vendor_name,
+        account_id: payload.account_id,
+        account_name: payload.account_name,
+        attachments: payload.attachments.map(completedTransactionAttachmentToAttachmentPayload),
+        lines: payload.lines.map(completedTransactionLineToLinePayload),
+    };
+}

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

@@ -1,6 +1,28 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+export const initialBulkUploadState = {
+    batchDetailsById: {},
+    batchList: [],
+    batchListFetchState: { fetchState: 'Not-Started', error: undefined },
+    batchStatusById: {},
+    completedSubTab: 'all',
+    completedTransactionsByPeriod: {},
+    confirmMatchStatus: { fetchState: 'Not-Started', error: undefined },
+    currentBatchId: undefined,
+    currentResultsTab: 'unmatched',
+    manualSearch: {
+        fetchState: { fetchState: 'Not-Started', error: undefined },
+        results: [],
+        searchQuery: '',
+    },
+    phase: 'idle',
+    sortKey: 'date',
+    sortOrder: 'descending',
+    uploadProgress: 0,
+    uploadStatus: { fetchState: 'Not-Started', error: undefined },
+};
 export const initialState = {
+    bulkUpload: initialBulkUploadState,
     uploadReceiptStatusById: {},
     refreshStatus: {
         fetchState: 'Not-Started',
@@ -120,7 +142,229 @@ const expenseAutomationMissingReceiptsView = createSlice({
         clearExpenseAutomationMissingReceiptsView(draft) {
             Object.assign(draft, initialState);
         },
+        // -- Bulk Upload Actions --
+        bulkUploadReceipts: {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            reducer(draft, _action) {
+                draft.bulkUpload.phase = 'uploading';
+                draft.bulkUpload.uploadProgress = 0;
+                draft.bulkUpload.uploadStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(files) {
+                return { payload: { files } };
+            },
+        },
+        updateBulkUploadProgress(draft, action) {
+            draft.bulkUpload.uploadProgress = action.payload;
+        },
+        bulkUploadReceiptsSuccess(draft, action) {
+            draft.bulkUpload.currentBatchId = action.payload.batchId;
+            draft.bulkUpload.uploadStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.bulkUpload.phase = 'matching';
+        },
+        bulkUploadReceiptsFailure(draft, action) {
+            draft.bulkUpload.uploadStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            draft.bulkUpload.phase = 'idle';
+        },
+        updateBulkUploadBatchStatus(draft, action) {
+            const batchStatus = action.payload;
+            draft.bulkUpload.batchStatusById[batchStatus.batchId] = batchStatus;
+        },
+        pusherBatchStatusUpdate(draft, action) {
+            const batchStatus = action.payload;
+            draft.bulkUpload.batchStatusById[batchStatus.batchId] = batchStatus;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        fetchBulkUploadBatchDetails(_draft) {
+            // trigger epic, no state change needed
+        },
+        fetchBulkUploadBatchDetailsSuccess(draft, action) {
+            const details = action.payload;
+            draft.bulkUpload.batchDetailsById[details.batchId] = details;
+            draft.bulkUpload.phase = 'completed';
+        },
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        fetchBulkUploadBatchDetailsFailure(draft, _action) {
+            draft.bulkUpload.phase = 'completed';
+        },
+        fetchBulkUploadBatches(draft) {
+            draft.bulkUpload.batchListFetchState = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        fetchBulkUploadBatchesSuccess(draft, action) {
+            draft.bulkUpload.batchList = action.payload;
+            draft.bulkUpload.batchListFetchState = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        fetchBulkUploadBatchesFailure(draft, action) {
+            draft.bulkUpload.batchListFetchState = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        confirmBulkUploadMatch: {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            reducer(draft, _action) {
+                draft.bulkUpload.confirmMatchStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(batchId, attachmentId, transactionId) {
+                return { payload: { batchId, attachmentId, transactionId } };
+            },
+        },
+        confirmBulkUploadMatchSuccess(draft, action) {
+            const { batchId, attachmentId, transactionId } = action.payload;
+            draft.bulkUpload.confirmMatchStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const details = draft.bulkUpload.batchDetailsById[batchId];
+            if (details != null) {
+                const file = details.files.find((f) => f.attachmentId === attachmentId);
+                if (file != null) {
+                    file.status = 'matched';
+                    file.matchedTransactionId = transactionId;
+                    file.candidates = undefined;
+                }
+                details.summary.matched += 1;
+                details.summary.possibleMatches = Math.max(0, details.summary.possibleMatches - 1);
+            }
+        },
+        confirmBulkUploadMatchFailure(draft, action) {
+            draft.bulkUpload.confirmMatchStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        setBulkUploadResultsTab(draft, action) {
+            draft.bulkUpload.currentResultsTab = action.payload;
+        },
+        setBulkUploadCompletedSubTab(draft, action) {
+            draft.bulkUpload.completedSubTab = action.payload;
+            draft.bulkUpload.completedTransactionsByPeriod = {};
+        },
+        setBulkUploadSortConfig(draft, action) {
+            draft.bulkUpload.sortKey = action.payload.sortKey;
+            draft.bulkUpload.sortOrder = action.payload.sortOrder;
+        },
+        clearBulkUpload(draft) {
+            Object.assign(draft.bulkUpload, initialBulkUploadState);
+        },
+        searchTransactionsForManualMatch: {
+            reducer(draft, action) {
+                draft.bulkUpload.manualSearch.searchQuery = action.payload.query;
+                draft.bulkUpload.manualSearch.fetchState = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                draft.bulkUpload.manualSearch.results = [];
+            },
+            prepare(query) {
+                return { payload: { query } };
+            },
+        },
+        searchTransactionsForManualMatchSuccess(draft, action) {
+            draft.bulkUpload.manualSearch.results = action.payload;
+            draft.bulkUpload.manualSearch.fetchState = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        searchTransactionsForManualMatchFailure(draft, action) {
+            draft.bulkUpload.manualSearch.fetchState = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        clearManualSearchResults(draft) {
+            draft.bulkUpload.manualSearch = initialBulkUploadState.manualSearch;
+        },
+        // -- Completed Transactions Actions --
+        fetchCompletedTransactions: {
+            reducer(draft, action) {
+                const periodId = toMonthYearPeriodId(action.payload.selectedPeriod);
+                const existing = draft.bulkUpload.completedTransactionsByPeriod[periodId];
+                if (action.payload.pageToken == null) {
+                    draft.bulkUpload.completedTransactionsByPeriod[periodId] = {
+                        fetchState: { fetchState: 'In-Progress', error: undefined },
+                        nextPageToken: null,
+                        totalCount: 0,
+                        transactionIds: [],
+                    };
+                }
+                else if (existing != null) {
+                    existing.fetchState = { fetchState: 'In-Progress', error: undefined };
+                }
+                else {
+                    draft.bulkUpload.completedTransactionsByPeriod[periodId] = {
+                        fetchState: { fetchState: 'In-Progress', error: undefined },
+                        nextPageToken: null,
+                        totalCount: 0,
+                        transactionIds: [],
+                    };
+                }
+            },
+            prepare(selectedPeriod, pageToken) {
+                return { payload: { selectedPeriod, pageToken } };
+            },
+        },
+        fetchCompletedTransactionsSuccess(draft, action) {
+            const { transactionIds, nextPageToken, totalCount, selectedPeriod } = action.payload;
+            const periodId = toMonthYearPeriodId(selectedPeriod);
+            const existing = draft.bulkUpload.completedTransactionsByPeriod[periodId];
+            if (existing != null) {
+                existing.transactionIds.push(...transactionIds);
+                existing.nextPageToken = nextPageToken;
+                existing.totalCount = totalCount;
+                existing.fetchState = { fetchState: 'Completed', error: undefined };
+            }
+            else {
+                draft.bulkUpload.completedTransactionsByPeriod[periodId] = {
+                    transactionIds,
+                    nextPageToken,
+                    totalCount,
+                    fetchState: { fetchState: 'Completed', error: undefined },
+                };
+            }
+        },
+        fetchCompletedTransactionsFailure(draft, action) {
+            const periodId = toMonthYearPeriodId(action.payload.selectedPeriod);
+            const existing = draft.bulkUpload.completedTransactionsByPeriod[periodId];
+            if (existing != null) {
+                existing.fetchState = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            }
+            else {
+                draft.bulkUpload.completedTransactionsByPeriod[periodId] = {
+                    fetchState: { fetchState: 'Error', error: action.payload.error },
+                    nextPageToken: null,
+                    totalCount: 0,
+                    transactionIds: [],
+                };
+            }
+        },
     },
 });
-export const { fetchMissingReceipts, fetchMissingReceiptsSuccess, fetchMissingReceiptsFailure, uploadMissingReceiptSuccess, updateMissingReceiptUploadState, updateMissingReceiptsUIState, markMissingReceiptAsDone, clearExpenseAutomationMissingReceiptsView, } = expenseAutomationMissingReceiptsView.actions;
+export const { fetchMissingReceipts, fetchMissingReceiptsSuccess, fetchMissingReceiptsFailure, uploadMissingReceiptSuccess, updateMissingReceiptUploadState, updateMissingReceiptsUIState, markMissingReceiptAsDone, clearExpenseAutomationMissingReceiptsView, 
+// Bulk Upload
+bulkUploadReceipts, updateBulkUploadProgress, bulkUploadReceiptsSuccess, bulkUploadReceiptsFailure, updateBulkUploadBatchStatus, pusherBatchStatusUpdate, fetchBulkUploadBatchDetails, fetchBulkUploadBatchDetailsSuccess, fetchBulkUploadBatchDetailsFailure, fetchBulkUploadBatches, fetchBulkUploadBatchesSuccess, fetchBulkUploadBatchesFailure, confirmBulkUploadMatch, confirmBulkUploadMatchSuccess, confirmBulkUploadMatchFailure, setBulkUploadResultsTab, setBulkUploadCompletedSubTab, setBulkUploadSortConfig, clearBulkUpload, searchTransactionsForManualMatch, searchTransactionsForManualMatchSuccess, searchTransactionsForManualMatchFailure, clearManualSearchResults, 
+// Completed Transactions
+fetchCompletedTransactions, fetchCompletedTransactionsSuccess, fetchCompletedTransactionsFailure, } = expenseAutomationMissingReceiptsView.actions;
 export default expenseAutomationMissingReceiptsView.reducer;

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

@@ -1,7 +1,7 @@
 import orderBy from 'lodash/orderBy';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
 import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
-import { getSupportedTransactionsByIds } from '../../../entity/transaction/transactionSelector';
+import { getSupportedTransactionById, getSupportedTransactionsByIds, } from '../../../entity/transaction/transactionSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationMissingReceiptsView(state) {
     const { expenseAutomationMissingReceiptsViewState, expenseAutomationViewState, transactionState, monthEndCloseChecksState, } = state;
@@ -47,6 +47,66 @@ export function getExpenseAutomationMissingReceiptsView(state) {
     const completionStatus = missingReceiptsCompletionStatus != null
         ? missingReceiptsCompletionStatus
         : 'incomplete';
+    const { bulkUpload } = expenseAutomationMissingReceiptsViewState;
+    const currentBatchStatus = bulkUpload.currentBatchId != null
+        ? bulkUpload.batchStatusById[bulkUpload.currentBatchId]
+        : undefined;
+    const currentBatchDetails = bulkUpload.currentBatchId != null
+        ? bulkUpload.batchDetailsById[bulkUpload.currentBatchId]
+        : undefined;
+    const resolvedFiles = currentBatchDetails?.files.map((file) => resolveBatchFile(file, transactionState));
+    const getSortValue = (file) => {
+        const t = file.matchedTransaction;
+        if (t == null) {
+            return null;
+        }
+        switch (bulkUpload.sortKey) {
+            case 'vendor':
+                return (t.vendorName ?? t.description)?.toLowerCase() ?? null;
+            case 'category': {
+                const line = t.lines?.[0];
+                return line?.account?.accountName?.toLowerCase() ?? null;
+            }
+            case 'class': {
+                const line = t.lines?.[0];
+                return line?.class?.className?.toLowerCase() ?? null;
+            }
+            case 'date':
+                return t.date.valueOf();
+            case 'amount':
+                return t.amount.amount;
+            default:
+                return null;
+        }
+    };
+    const bulkUploadSortDirection = bulkUpload.sortOrder === 'ascending' ? 'asc' : 'desc';
+    const matchedFiles = orderBy(resolvedFiles?.filter((f) => f.status === 'matched') ?? [], getSortValue, bulkUploadSortDirection);
+    const unmatchedFiles = orderBy(resolvedFiles?.filter((f) => f.status === 'un_matched' || f.status === 'no_match') ?? [], getSortValue, bulkUploadSortDirection);
+    const progress = currentBatchStatus != null
+        ? {
+            ...currentBatchStatus.progress,
+            percentage: currentBatchStatus.progress.total > 0
+                ? Math.round((currentBatchStatus.progress.processed /
+                    currentBatchStatus.progress.total) *
+                    100)
+                : 0,
+        }
+        : { total: 0, processed: 0, percentage: 0 };
+    const pastBatches = bulkUpload.batchList.filter((b) => b.batchId !== bulkUpload.currentBatchId);
+    const completedTransactionsForPeriod = monthYearPeriodId != null
+        ? bulkUpload.completedTransactionsByPeriod[monthYearPeriodId]
+        : undefined;
+    const completedTransactionIds = completedTransactionsForPeriod?.transactionIds ?? [];
+    const resolvedCompletedTransactions = getSupportedTransactionsByIds(transactionState, completedTransactionIds);
+    const resolvedBatchDetails = currentBatchDetails != null && resolvedFiles != null
+        ? {
+            batchId: currentBatchDetails.batchId,
+            createdAt: currentBatchDetails.createdAt,
+            files: resolvedFiles,
+            status: currentBatchDetails.status,
+            summary: currentBatchDetails.summary,
+        }
+        : undefined;
     return {
         fetchState,
         error,
@@ -55,5 +115,58 @@ export function getExpenseAutomationMissingReceiptsView(state) {
         refreshStatus,
         transactions: sortedTransactions,
         completionStatus,
+        bulkUpload: {
+            phase: bulkUpload.phase,
+            uploadStatus: bulkUpload.uploadStatus,
+            batchStatus: currentBatchStatus,
+            batchDetails: resolvedBatchDetails,
+            completedSubTab: bulkUpload.completedSubTab,
+            completedTransactions: {
+                fetchState: completedTransactionsForPeriod?.fetchState ?? {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                },
+                nextPageToken: completedTransactionsForPeriod?.nextPageToken ?? null,
+                totalCount: completedTransactionsForPeriod?.totalCount ?? 0,
+                transactions: resolvedCompletedTransactions,
+            },
+            matchedFiles,
+            unmatchedFiles,
+            progress,
+            currentResultsTab: bulkUpload.currentResultsTab,
+            sortKey: bulkUpload.sortKey,
+            sortOrder: bulkUpload.sortOrder,
+            batchList: bulkUpload.batchList,
+            batchListFetchState: bulkUpload.batchListFetchState,
+            pastBatches,
+            confirmMatchStatus: bulkUpload.confirmMatchStatus,
+            manualSearch: bulkUpload.manualSearch,
+            uploadProgress: bulkUpload.uploadProgress,
+        },
+    };
+}
+function resolveBatchFile(file, transactionState) {
+    const matchedTransaction = file.matchedTransactionId != null
+        ? getSupportedTransactionById(transactionState, file.matchedTransactionId)
+        : undefined;
+    const candidates = file.candidates
+        ?.map((ref) => {
+        const transaction = getSupportedTransactionById(transactionState, ref.transactionId);
+        return transaction != null
+            ? { transaction, matchScore: ref.matchScore }
+            : undefined;
+    })
+        .filter((c) => c != null);
+    return {
+        attachmentId: file.attachmentId,
+        fileId: file.fileId,
+        filename: file.filename,
+        filePreviewUrl: file.filePreviewUrl,
+        status: file.status,
+        matchedTransaction,
+        candidates: candidates != null && candidates.length > 0
+            ? candidates
+            : undefined,
+        matchSource: file.matchSource,
     };
 }