@zeniai/client-epic-state 4.19.28 → 4.19.30

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/retryJeSchedulesEpic.js

@@ -0,0 +1,78 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../responsePayload';
+import { fetchMonthEndCloseChecks } from '../../../monthEndCloseChecksView/monthEndCloseChecksViewReducer';
+import { preparePayloadForRetryPosting } from '../../payload/jeSchedulesPayload';
+import { removeFailedJeScheduleTransactionKey, removeJeScheduleLocalDataById, retryJeSchedule, retryJeScheduleFailure, retryJeScheduleSuccess, } from '../../reducers/jeSchedulesViewReducer';
+export const retryJeScheduleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(retryJeSchedule.match), switchMap((action) => {
+    const state = state$.value;
+    const { expenseAutomationJESchedulesViewState: { jeScheduleLocalDataById }, expenseAutomationViewState: { selectedPeriodByTenantId }, } = state;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const { scheduledJournalEntryID, jeScheduleTransactionKey } = action.payload;
+    const jeSchedule = jeScheduleLocalDataById[scheduledJournalEntryID];
+    if (jeSchedule == null) {
+        return from([]);
+    }
+    const payload = { ...preparePayloadForRetryPosting(jeSchedule) };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/schedules/retry_sje_posting`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response)) {
+            const updateActions = [];
+            updateActions.push(retryJeScheduleSuccess({
+                scheduledJournalEntryID,
+            }), removeFailedJeScheduleTransactionKey(jeScheduleTransactionKey, selectedPeriod), removeJeScheduleLocalDataById({ scheduledJournalEntryID }), // Important to remove localdata after success.
+            fetchMonthEndCloseChecks({
+                tenantId: currentTenant.tenantId,
+                period: selectedPeriod,
+                refreshViewInBackground: true,
+            }), openSnackbar({
+                messageSection: 'je_posted',
+                messageText: 'success',
+                type: 'success',
+            }));
+            return from(updateActions);
+        }
+        else {
+            const updateActions = [];
+            updateActions.push(retryJeScheduleFailure({
+                status: response.status,
+                scheduledJournalEntryID,
+            }));
+            updateActions.push(openSnackbar({
+                messageSection: 'je_posted',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }));
+            return from(updateActions);
+        }
+    }), catchError((error) => {
+        const updateActions = [];
+        updateActions.push(retryJeScheduleFailure({
+            status: createZeniAPIStatus('Unexpected Error', 'retry JE schedule posting REST API call errored out' +
+                JSON.stringify(error)),
+            scheduledJournalEntryID,
+        }));
+        updateActions.push(openSnackbar({
+            messageSection: 'je_posted',
+            messageText: 'failed',
+            type: 'error',
+            variables: [
+                {
+                    variableName: '_api-error_',
+                    variableValue: JSON.stringify(error),
+                },
+            ],
+        }));
+        return from(updateActions);
+    }));
+}));

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

@@ -0,0 +1,54 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { toMonthYearPeriodId, toString, } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchMissingReceipts, fetchMissingReceiptsFailure, fetchMissingReceiptsSuccess, } from '../../reducers/missingReceiptsViewReducer';
+export const fetchMissingReceiptsEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchMissingReceipts.match), switchMap((action) => {
+    const state = state$.value;
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationMissingReceiptsViewState: { transactionIdsBySelectedPeriod, fetchState, }, } = state;
+    const { period, cacheOverride, minimumTransactionAmount } = action.payload;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const transactionIds = transactionIdsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] ??
+        [];
+    if (cacheOverride === true ||
+        transactionIds.length === 0 ||
+        fetchState === 'Not-Started') {
+        const queryParam = {
+            start_date: toString(period.start),
+            end_date: toString(period.end),
+            total_amount_min: minimumTransactionAmount.amount,
+            is_attachment_missing_only: true,
+            sort_by: 'transaction_date',
+            sort_order: 'desc',
+        };
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const updateActions = [];
+                updateActions.push(updateTransactions(response.data.transactions, (value) => value.transaction_id));
+                updateActions.push(fetchMissingReceiptsSuccess({
+                    transactionsPayload: response.data.transactions,
+                    selectedPeriod,
+                }));
+                return from(updateActions);
+            }
+            else {
+                return of(fetchMissingReceiptsFailure({
+                    status: response.status,
+                    selectedPeriod,
+                }));
+            }
+        }), catchError((error) => of(fetchMissingReceiptsFailure({
+            status: createZeniAPIStatus('Unexpected Error', 'fetch missing receipts REST API call errored out' +
+                JSON.stringify(error)),
+            selectedPeriod,
+        }))));
+    }
+    else {
+        return from([]);
+    }
+}));

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

@@ -0,0 +1,22 @@
+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 { uploadMissingReceiptSuccess } from '../../reducers/missingReceiptsViewReducer';
+export const uploadMissingReceiptSuccessEpic = (actions$, state$) => actions$.pipe(filter(uploadMissingReceiptSuccess.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];
+        updateActions.push(fetchMonthEndCloseChecks({
+            tenantId: currentTenant.tenantId,
+            period: monthEndChecksPeriod,
+            refreshViewInBackground: true,
+        }));
+    }
+    return from(updateActions);
+}));

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

@@ -0,0 +1,72 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { toString } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { updateTransactions } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { getLineItemsByTransactionsIdsFromResponse } from '../../helpers/transactionCategorizationLocalDataHelper';
+import { fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationSuccess, initializeTransactionCategorizationViewLocalData, resetOtherTabsFetchState, updateTotalCountForTransactionCategorization, updateTransactionCategorizationUIState, } from '../../reducers/transactionsViewReducer';
+import { TRANSACTIONS_TABS, toTransactionsSortKey, } from '../../types/transactionsViewState';
+export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTransactionCategorization.match), switchMap((action) => {
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationTransactionsViewState, } = state$.value;
+    const { period, keepExistingListItems, selectedTab, refreshViewInBackground, } = action.payload;
+    const uiState = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab].uiState;
+    const { pageToken, sortOrder, sortKey } = uiState;
+    const currentTenant = getCurrentTenant(state$.value);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const queryParam = {
+        start_date: toString(period.start),
+        end_date: toString(period.end),
+        auto_categorized: selectedTab === 'autoCategorized',
+        sort_by: toTransactionsSortKey(sortKey),
+        sort_order: sortOrder === 'ascending' ? 'asc' : 'desc',
+        page_token: pageToken,
+        page_size: 25,
+        search_text: uiState.searchString,
+    };
+    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 updateActions = [];
+            updateActions.push(updateTransactions(response.data.transactions, (value) => value.transaction_id, 'merge'));
+            const transactionIds = response.data.transactions.map((transaction) => transaction.transaction_id);
+            const lineItemsByTransactionIds = getLineItemsByTransactionsIdsFromResponse(response.data.transactions);
+            updateActions.push(updateTransactionCategorizationUIState({
+                selectedTab,
+                uiState: {
+                    ...uiState,
+                    pageToken: response.data.next_page_token ?? null,
+                },
+            }));
+            updateActions.push(initializeTransactionCategorizationViewLocalData(selectedTab, transactionIds, selectedPeriod, keepExistingListItems, response.data.next_page_token ?? null, response.data.total_count, lineItemsByTransactionIds, refreshViewInBackground, action.payload.isUncategorizedExpenseCategoryEnabled));
+            updateActions.push(updateTotalCountForTransactionCategorization({
+                selectedPeriod,
+                selectedTab,
+                totalCount: response.data.total_count,
+            }));
+            updateActions.push(resetOtherTabsFetchState({
+                refreshViewInBackground,
+                tabs: TRANSACTIONS_TABS.filter((tab) => selectedTab !== tab),
+            }));
+            updateActions.push(fetchTransactionCategorizationSuccess({
+                refreshViewInBackground,
+                selectedTab,
+                status: response.status,
+            }));
+            return from(updateActions);
+        }
+        else {
+            return of(fetchTransactionCategorizationFailure({
+                selectedPeriod,
+                selectedTab,
+                status: response.status,
+            }));
+        }
+    }), catchError((error) => of(fetchTransactionCategorizationFailure({
+        selectedPeriod,
+        selectedTab,
+        status: createZeniAPIStatus('Unexpected Error', 'fetch Transaction Categorization REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

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

@@ -0,0 +1,40 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
+import { fetchAccountList } from '../../../accountList/accountListReducer';
+import { fetchClassList } from '../../../classList/classListReducer';
+import { fetchOwnerList } from '../../../ownerList/ownerListReducer';
+import { fetchTransactionCategorization, fetchTransactionCategorizationView, } from '../../reducers/transactionsViewReducer';
+export const fetchTransactionCategorizationViewEpic = (actions$, state$) => actions$.pipe(filter(fetchTransactionCategorizationView.match), mergeMap((action) => {
+    const { selectedTab, cacheOverride, keepExistingListItems, pageToken, period, refreshViewInBackground, searchString, resetListItems, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+    const updateActions = [];
+    const { expenseAutomationTransactionsViewState } = state$.value;
+    const { fetchState, transactionIdsBySelectedPeriod } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab];
+    const monthYearPeriod = {
+        month: period.start.month,
+        year: period.start.year,
+    };
+    const transactionIds = transactionIdsBySelectedPeriod[toMonthYearPeriodId(monthYearPeriod)] ??
+        [];
+    const accountList = state$.value.accountListState.byReportId['accountList'];
+    if (accountList.hasValidState() === false &&
+        accountList.fetchState === 'Not-Started') {
+        updateActions.push(fetchAccountList('accountList', true));
+    }
+    const classList = state$.value.classListState;
+    if (classList.hasValidState() === false &&
+        classList.fetchState === 'Not-Started') {
+        updateActions.push(fetchClassList());
+    }
+    const vendorOwnerList = state$.value.ownerListState;
+    if (vendorOwnerList.hasValidState() === false &&
+        vendorOwnerList.fetchState === 'Not-Started') {
+        updateActions.push(fetchOwnerList());
+    }
+    if (cacheOverride === true ||
+        fetchState === 'Not-Started' ||
+        transactionIds.length === 0) {
+        updateActions.push(fetchTransactionCategorization(selectedTab, period, cacheOverride, keepExistingListItems, searchString, pageToken, refreshViewInBackground, resetListItems, isUncategorizedExpenseCategoryEnabled));
+    }
+    return from(updateActions);
+}));

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

@@ -0,0 +1,79 @@
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { getTransactionWithCOT } from '../../../../entity/transaction/transactionHelper';
+import { getSupportedTransactionsByIds } from '../../../../entity/transaction/transactionSelector';
+import { getUncategorizedAccounts } from '../../../accountList/accountListSelector';
+import { mergeTabSpecificLineItems, toTransactionDetailLocalData, } from '../../helpers/transactionCategorizationLocalDataHelper';
+import { initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, } from '../../reducers/transactionsViewReducer';
+import { initialSupportedTransactionCategorization, } from '../../types/transactionsViewState';
+export const initializeTransactionCategorizationViewLocalDataEpic = (actions$, state$) => actions$.pipe(filter(initializeTransactionCategorizationViewLocalData.match), mergeMap((action) => {
+    const { transactionIds, selectedPeriod, keepExistingListItems, selectedTab, pageToken, totalCount, lineItemsByTransactionIds, refreshViewInBackground, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+    const fetchActions = [];
+    const { transactionState, expenseAutomationTransactionsViewState } = state$.value;
+    const { transactionReviewLocalDataById } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab];
+    const transactionLocalData = keepExistingListItems === true
+        ? { ...transactionReviewLocalDataById }
+        : {};
+    const transactions = getSupportedTransactionsByIds(transactionState, transactionIds);
+    const uncategorizedIncomeExpense = getUncategorizedAccounts(state$.value.accountState, state$.value.accountListState, 'accountList');
+    transactions.forEach((transaction) => {
+        const transactionWithCOT = getTransactionWithCOT(transaction);
+        const newTransactionsLocalData = toTransactionDetailLocalData(transactionWithCOT, selectedTab, lineItemsByTransactionIds[transaction.id], uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled);
+        if (transactionLocalData[transaction.id] == null) {
+            transactionLocalData[transaction.id] = {
+                ...initialSupportedTransactionCategorization,
+                transactionId: transaction.id,
+                transactionReviewLocalData: {
+                    ...newTransactionsLocalData,
+                    sortedLineItems: transaction.lines?.map((line) => line.id) ?? [],
+                },
+            };
+        }
+        else {
+            transactionLocalData[transaction.id] = {
+                transactionId: transaction.id,
+                transactionReviewLocalData: {
+                    ...transactionLocalData[transaction.id]
+                        .transactionReviewLocalData,
+                    ...{
+                        ...newTransactionsLocalData,
+                        lineItemById: {
+                            ...mergeTransactionLineItems(transactionLocalData[transaction.id]
+                                .transactionReviewLocalData.lineItemById, newTransactionsLocalData.lineItemById),
+                        },
+                        sortedLineItems: [
+                            ...new Set(transactionLocalData[transaction.id].transactionReviewLocalData.sortedLineItems.concat(newTransactionsLocalData.sortedLineItems)),
+                        ],
+                        tabSpecificLineItems: mergeTabSpecificLineItems(transactionLocalData[transaction.id]
+                            .transactionReviewLocalData.tabSpecificLineItems, selectedTab, newTransactionsLocalData.tabSpecificLineItems),
+                    },
+                },
+            };
+        }
+    });
+    fetchActions.push(saveTransactionCategorizationLocalData({
+        selectedTab,
+        transactionIds,
+        selectedPeriod,
+        keepExistingListItems,
+        transactionLocalData,
+        pageToken,
+        totalCount,
+        refreshViewInBackground,
+    }));
+    return from(fetchActions);
+}));
+// Better option to merge line items using this helper than merging inline to avoid overwriting the line items in future
+// This function is used to merge the line items of a transaction so that the line items are not overwritten
+function mergeTransactionLineItems(existingLineItems, newLineItems) {
+    const mergedLineItems = {
+        ...existingLineItems,
+    };
+    for (const id of Object.keys(newLineItems)) {
+        mergedLineItems[id] = {
+            ...existingLineItems[id],
+            ...newLineItems[id],
+        };
+    }
+    return mergedLineItems;
+}

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

@@ -0,0 +1,137 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { convertToPeriod, toAbsoluteDay, toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { removeTransactionCategorization } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchMonthEndCloseChecks } from '../../../monthEndCloseChecksView/monthEndCloseChecksViewReducer';
+import { getSnackbarMessageForTransactionReview } from '../../helpers/transactionCategorizationLocalDataHelper';
+import { fetchTransactionCategorizationView, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateTotalCountForTransactionCategorization, } from '../../reducers/transactionsViewReducer';
+export const markTransactionAsNotMiscategorizedEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(markTransactionAsNotMiscategorized.match), mergeMap((action) => {
+    const { expenseAutomationViewState, expenseAutomationTransactionsViewState, } = state$.value;
+    const { transactionsInReview, selectedTab, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+    const transactionsSuccess = transactionsInReview.transactions_update_success;
+    const transactionsFailed = transactionsInReview.transactions_update_failed;
+    const currentTenant = getCurrentTenant(state$.value);
+    const selectedPeriod = expenseAutomationViewState.selectedPeriodByTenantId[currentTenant.tenantId];
+    const otherTab = selectedTab === 'review' ? 'autoCategorized' : 'review';
+    const currentTabViewState = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab];
+    const otherTabViewState = expenseAutomationTransactionsViewState.transactionCategorizationView[otherTab];
+    const { uiState } = currentTabViewState;
+    const transactionsIdsFailed = transactionsFailed.map((transaction) => transaction.transaction_id);
+    const actions = [];
+    if (transactionsFailed.length > 0 && transactionsSuccess.length === 0) {
+        actions.push(openSnackbar(getSnackbarMessageForTransactionReview(transactionsSuccess.length, transactionsFailed.length, 0)));
+    }
+    if (transactionsSuccess.length > 0) {
+        return zeniAPI
+            .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/mark-as-reviewed`, { transactions_reviewed: transactionsSuccess })
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const reviewedSuccess = response.data.transactions_reviewed_success;
+                const reviewedFailed = response.data.transactions_reviewed_failed;
+                // Build maps for success and failed line items per transaction
+                const successLineItemsByTransactionId = {};
+                const failedLineItemsByTransactionId = {};
+                reviewedSuccess.forEach((transaction) => {
+                    successLineItemsByTransactionId[transaction.transaction_id] =
+                        transaction.line_ids;
+                });
+                reviewedFailed.forEach((transaction) => {
+                    failedLineItemsByTransactionId[transaction.transaction_id] =
+                        transaction.line_ids;
+                });
+                const allReviewedTransactionIds = [
+                    ...new Set([
+                        ...Object.keys(successLineItemsByTransactionId),
+                        ...Object.keys(failedLineItemsByTransactionId),
+                    ]),
+                ];
+                const allCategorizedTransactionIds = allReviewedTransactionIds.filter((transactionId) => !(transactionId in failedLineItemsByTransactionId));
+                const transactionsToRemoveFromEntity = [];
+                const transactionsToRemoveFromTab = [];
+                const transactionsToUpdateLineItems = {};
+                allReviewedTransactionIds.forEach((transactionId) => {
+                    const successLineIds = successLineItemsByTransactionId[transactionId] ?? [];
+                    const failedLineIds = failedLineItemsByTransactionId[transactionId] ?? [];
+                    // Get current tab's line items for this transaction
+                    const currentTabLineItems = currentTabViewState.transactionReviewLocalDataById[transactionId]?.transactionReviewLocalData.tabSpecificLineItems[selectedTab] ?? [];
+                    // Check if transaction exists in other tab
+                    const otherTabLineItems = otherTabViewState.transactionReviewLocalDataById[transactionId]?.transactionReviewLocalData.tabSpecificLineItems[otherTab] ?? [];
+                    const existsInOtherTab = otherTabLineItems.length > 0;
+                    const remainingLineItems = currentTabLineItems.filter((lineId) => {
+                        const isSuccess = successLineIds.includes(lineId);
+                        const isFailed = failedLineIds.includes(lineId);
+                        if (selectedTab === 'review') {
+                            return !isSuccess || isFailed;
+                        }
+                        else {
+                            return !isSuccess && !isFailed;
+                        }
+                    });
+                    if (remainingLineItems.length > 0) {
+                        transactionsToUpdateLineItems[transactionId] =
+                            remainingLineItems;
+                    }
+                    else {
+                        transactionsToUpdateLineItems[transactionId] = [];
+                        transactionsToRemoveFromTab.push(transactionId);
+                        if (!existsInOtherTab) {
+                            transactionsToRemoveFromEntity.push(transactionId);
+                        }
+                    }
+                });
+                //considering only failed categorization transactions
+                const allFailedIds = [...transactionsIdsFailed];
+                const totalCountByPeriod = uiState.totalCount[toMonthYearPeriodId(selectedPeriod)];
+                const updatedTotalCount = transactionsToRemoveFromTab.length === 0
+                    ? totalCountByPeriod
+                    : totalCountByPeriod - transactionsToRemoveFromTab.length;
+                actions.push(updateStatusForTransactionNotMiscategorizedUpdateForCategorization(selectedTab, allReviewedTransactionIds, // uncheckTransactionIds
+                transactionsToRemoveFromTab, // removeTransactionIdsFromSelectedPeriod
+                selectedPeriod, 'Completed', undefined, transactionsToUpdateLineItems // updateLineItemsByTransactionId
+                ));
+                // Only remove transactions that don't exist in other tab
+                if (transactionsToRemoveFromEntity.length > 0) {
+                    actions.push(removeTransactionCategorization({
+                        transactionIds: transactionsToRemoveFromEntity,
+                    }));
+                }
+                // refetch review tab refresh fetch state to let it auto refresh
+                if (selectedTab === 'autoCategorized' &&
+                    Object.keys(failedLineItemsByTransactionId).length > 0) {
+                    const period = convertToPeriod(selectedPeriod);
+                    const timePeriodStart = toAbsoluteDay(period.start);
+                    const timePeriodEnd = toAbsoluteDay(period.end);
+                    if (timePeriodStart != null && timePeriodEnd != null) {
+                        actions.push(fetchTransactionCategorizationView('review', { start: timePeriodStart, end: timePeriodEnd }, true, // cacheOverride = true to force refresh
+                        false, undefined, undefined, true, // refreshViewInBackground
+                        false, isUncategorizedExpenseCategoryEnabled));
+                    }
+                }
+                actions.push(updateTotalCountForTransactionCategorization({
+                    selectedPeriod,
+                    selectedTab,
+                    totalCount: updatedTotalCount,
+                }));
+                actions.push(openSnackbar(getSnackbarMessageForTransactionReview(transactionsSuccess.length -
+                    allCategorizedTransactionIds.length, allFailedIds.length, allCategorizedTransactionIds.length)));
+                if (currentTenant != null) {
+                    actions.push(fetchMonthEndCloseChecks({
+                        tenantId: currentTenant.tenantId,
+                        period: selectedPeriod,
+                        refreshViewInBackground: true,
+                    }));
+                }
+                return from(actions);
+            }
+            else {
+                return of(updateStatusForTransactionNotMiscategorizedUpdateForCategorization(action.payload.selectedTab, [], [], selectedPeriod, 'Error', response.status));
+            }
+        }), catchError((error) => of(updateStatusForTransactionNotMiscategorizedUpdateForCategorization(action.payload.selectedTab, [], [], selectedPeriod, 'Error', createZeniAPIStatus('Unexpected Error', `Transaction mark miscategorized as correct REST API call errored out ${JSON.stringify(error)}`)))));
+    }
+    else {
+        return from(actions);
+    }
+}));

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

@@ -0,0 +1,24 @@
+import recordGet from 'lodash/get';
+import { from } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { getSupportedTransactionsByIds } from '../../../../entity/transaction/transactionSelector';
+import { getUncategorizedAccounts } from '../../../accountList/accountListSelector';
+import { toTransactionUpdatesFromTransactionCategorizationLocalData } from '../../helpers/saveTransactionHelper';
+import { saveTransactionCategorization, updateTransactionCategorization, } from '../../reducers/transactionsViewReducer';
+export const saveTransactionCategorizationEpic = (actions$, state$) => actions$.pipe(filter(saveTransactionCategorization.match), mergeMap((action) => {
+    const { transactionIds, cotTrackingByTransactionId, selectedTab, isUncategorizedExpenseCategoryEnabled, } = action.payload;
+    const fetchActions = [];
+    const { transactionState, expenseAutomationTransactionsViewState } = state$.value;
+    const transactionSaveUpdates = [];
+    const transactions = getSupportedTransactionsByIds(transactionState, transactionIds);
+    transactions.forEach((transaction) => {
+        const detail = recordGet(expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab].transactionReviewLocalDataById, transaction.id, undefined);
+        const uncategorizedIncomeExpense = getUncategorizedAccounts(state$.value.accountState, state$.value.accountListState, 'accountList');
+        const localData = detail?.transactionReviewLocalData;
+        if (localData != null) {
+            transactionSaveUpdates.push(toTransactionUpdatesFromTransactionCategorizationLocalData(localData, transaction, uncategorizedIncomeExpense));
+        }
+    });
+    fetchActions.push(updateTransactionCategorization(selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled));
+    return from(fetchActions);
+}));