@zeniai/client-epic-state 5.0.69-betaML31 → 5.0.69-betaML4

package/lib/esm/view/createTransferEntry/createTransferEntryReducer.js

@@ -0,0 +1,56 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { initialCreateTransferEntryState, } from './createTransferEntryState';
+export const initialState = initialCreateTransferEntryState;
+const createTransferEntrySlice = createSlice({
+    name: 'createTransferEntry',
+    initialState,
+    reducers: {
+        fetchAccountsForTransferFlow(draft, action) {
+            draft.transferAccountsByType[action.payload.kind].fetchState =
+                'In-Progress';
+        },
+        updateAccountsForTransferFlow(draft, action) {
+            const slice = draft.transferAccountsByType[action.payload.kind];
+            slice.fetchState = 'Completed';
+            slice.accountIds = action.payload.accountIds;
+        },
+        updateAccountsForTransferFlowFailure(draft, action) {
+            draft.transferAccountsByType[action.payload.kind].fetchState = 'Error';
+        },
+        createTransferEntry: {
+            prepare(payload) {
+                return { payload };
+            },
+            reducer(draft) {
+                draft.createTransferEntryStatus = 'In-Progress';
+            },
+        },
+        createTransferEntrySuccess(draft) {
+            draft.createTransferEntryStatus = 'Completed';
+        },
+        createTransferEntryFailure(draft) {
+            draft.createTransferEntryStatus = 'Error';
+        },
+        resetCreateTransferEntryStatus(draft) {
+            draft.createTransferEntryStatus = 'Not-Started';
+        },
+        createTransferEntryReplacedTransaction: {
+            prepare(previousTransactionId, newTransactionId) {
+                return { payload: { newTransactionId, previousTransactionId } };
+            },
+            reducer(draft, action) {
+                draft.lastTransferEntryReplacement = action.payload;
+            },
+        },
+        /**
+         * One-shot acknowledgement: the host has consumed the route-replacement
+         * signal and navigated to the new transaction url, so we can drop the
+         * record. Re-dispatching is idempotent.
+         */
+        clearTransferEntryRouteReplacement(draft) {
+            draft.lastTransferEntryReplacement = undefined;
+        },
+    },
+});
+export const { fetchAccountsForTransferFlow, updateAccountsForTransferFlow, updateAccountsForTransferFlowFailure, createTransferEntry, createTransferEntrySuccess, createTransferEntryFailure, resetCreateTransferEntryStatus, createTransferEntryReplacedTransaction, clearTransferEntryRouteReplacement, } = createTransferEntrySlice.actions;
+export default createTransferEntrySlice.reducer;

package/lib/esm/view/createTransferEntry/createTransferEntrySelector.js

@@ -0,0 +1,64 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { getAccountBase, getAccountBaseForCreditCardTransferAccounts, getAccountBaseForTransferAccounts, } from '../../entity/account/accountSelector';
+import { getAccountList } from '../accountList/accountListSelector';
+export function getCreateTransferEntryStatus(state) {
+    return state.createTransferEntryState.createTransferEntryStatus;
+}
+export function getLastTransferEntryReplacement(state) {
+    return state.createTransferEntryState.lastTransferEntryReplacement;
+}
+/**
+ * Shared resolver for the credit/debit dropdowns in the transfer drawer.
+ *
+ * Resolution policy (intentional):
+ * 1. Prefer the dedicated API fetch results (`transferEntryEligible` for the
+ *    debit pool, `creditCardOnlyEligible` for the credit-card-payment credit
+ *    pool).
+ * 2. If the dedicated fetch returns an empty list while the COA is loaded,
+ *    fall back to the COA: the full account list for `transferEntryEligible`,
+ *    and COA accounts filtered to `credit_card` for `creditCardOnlyEligible`.
+ *    This keeps the dropdown populated for older tenants where the dedicated
+ *    endpoints haven't been backfilled yet.
+ *
+ * Intent — what this selector deliberately does NOT do:
+ * - Does NOT distinguish "fetch in-flight" / "fetch errored" / "fetch returned
+ *   empty" — all three collapse to the COA fallback. The product preference
+ *   is "always show something selectable" over "show a spinner that may never
+ *   resolve". Loading/error UI belongs in the view layer; if you need a
+ *   spinner, observe the `fetchState` on `transferAccountsByType[kind]`
+ *   separately rather than changing the resolution policy here.
+ * - Does NOT enforce "API result is authoritative even if empty" — a tenant
+ *   whose dedicated endpoint is correctly returning `[]` (e.g. no eligible
+ *   transfer destinations) will still see the COA. That trade-off is
+ *   accepted because the alternative blocks the user from picking anything;
+ *   the backend distinguishes "no result" from "endpoint not implemented" by
+ *   surfacing an error response, which the view layer handles separately.
+ *
+ * Memoized with reselect so consuming view-models don't recompute on every
+ * unrelated state change.
+ */
+export const getResolvedTransferAccounts = createSelector([
+    (state) => state.accountState,
+    (state) => state.accountListState,
+    (state) => state.createTransferEntryState.transferAccountsByType
+        .transferEntryEligible.accountIds,
+    (state) => state.createTransferEntryState.transferAccountsByType
+        .creditCardOnlyEligible.accountIds,
+], (accountState, accountListState, transferEligibleIds, creditCardOnlyIds) => {
+    const accountList = getAccountList(accountState, accountListState, 'accountList');
+    const transferEligibleFromApi = transferEligibleIds
+        .map((id) => getAccountBaseForTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    const coaFallbackAllAccounts = accountList.accounts
+        .map((a) => getAccountBase(accountState, a.accountId, 'account_list'))
+        .filter((account) => account != null);
+    const transferAccountsList = transferEligibleFromApi.length > 0
+        ? transferEligibleFromApi
+        : coaFallbackAllAccounts;
+    const creditCardFromApi = creditCardOnlyIds
+        .map((id) => getAccountBaseForCreditCardTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    const coaFallbackCreditCards = coaFallbackAllAccounts.filter((a) => a.accountType === 'credit_card');
+    const creditCardTransferAccountsList = creditCardFromApi.length > 0 ? creditCardFromApi : coaFallbackCreditCards;
+    return { creditCardTransferAccountsList, transferAccountsList };
+});

package/lib/esm/view/createTransferEntry/createTransferEntryState.js

@@ -0,0 +1,17 @@
+/** Which pool `fetchAccountsForTransferFlow` / transfer-flow epic should load. */
+export const TRANSFER_ACCOUNTS_FETCH_TYPE = [
+    'transferEntryEligible',
+    'creditCardOnlyEligible',
+];
+const initialTransferAccountsState = {
+    accountIds: [],
+    fetchState: 'Not-Started',
+};
+export const initialCreateTransferEntryState = {
+    createTransferEntryStatus: 'Not-Started',
+    lastTransferEntryReplacement: undefined,
+    transferAccountsByType: {
+        transferEntryEligible: initialTransferAccountsState,
+        creditCardOnlyEligible: initialTransferAccountsState,
+    },
+};

package/lib/esm/view/createTransferEntry/epics/createTransferEntryEpic.js

@@ -0,0 +1,112 @@
+import { concat, from, timer } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../entity/snackbar/snackbarReducer';
+import { toTransactionID } from '../../../entity/transaction/payloadTypes/transactionIDPayload';
+import { removeTransaction, updateTransaction, } from '../../../entity/transaction/transactionReducer';
+import { isSuccessResponse } from '../../../responsePayload';
+import { removeTransactionFromAllTabs } from '../../expenseAutomationView/reducers/transactionsViewReducer';
+import { initializeTransactionDetailLocalData, removeTransactionDetail, } from '../../transactionDetail/transactionDetailReducer';
+import { getTransactionDetailKey } from '../../transactionDetail/transactionDetailState';
+import { clearTransferEntryRouteReplacement, createTransferEntry, createTransferEntryFailure, createTransferEntryReplacedTransaction, createTransferEntrySuccess, resetCreateTransferEntryStatus, } from '../createTransferEntryReducer';
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+function transactionIdsAreEqual(a, b) {
+    return a.id === b.id && a.type === b.type;
+}
+const successSnackbar = () => openSnackbar({
+    messageSection: 'create_transfer_entry',
+    messageText: 'success',
+    type: 'success',
+});
+const failureSnackbar = () => openSnackbar({
+    messageSection: 'create_transfer_entry',
+    messageText: 'failed',
+    type: 'error',
+});
+function buildFailureActions() {
+    return [createTransferEntryFailure(), failureSnackbar()];
+}
+function buildSuccessSideEffects(sourceTransactionId) {
+    return [
+        createTransferEntrySuccess(),
+        removeTransactionFromAllTabs(sourceTransactionId),
+        successSnackbar(),
+    ];
+}
+function buildPreviousTransactionCleanupActions(previousTransactionId) {
+    return [
+        removeTransaction(getTransactionDetailKey(previousTransactionId)),
+        removeTransactionDetail(previousTransactionId),
+        clearTransferEntryRouteReplacement(),
+    ];
+}
+/**
+ * Emits `resetCreateTransferEntryStatus()` (and, on the replacement path, the
+ * follow-up cleanup actions) one scheduler tick after the success actions.
+ *
+ * Why the `timer(0)` (and not synchronous emission):
+ * On the replacement path the host (web-app-ui) watches
+ * `lastTransferEntryReplacement`, navigates to the new transaction url, and
+ * then sees `clearTransferEntryRouteReplacement` clear the signal. If we
+ * dispatched the cleanup actions in the same tick as
+ * `createTransferEntryReplacedTransaction`, redux subscribers would observe
+ * `lastTransferEntryReplacement` flicker on then off in a single render, and
+ * the old transaction's state (which the still-mounted detail view may be
+ * reading) would be torn down before the host has had a chance to start
+ * navigating. Deferring by one microtask gives the host exactly one render
+ * pass to react before we tear down the previous transaction.
+ */
+function delayedResetAndPreviousCleanup(previousTransactionId) {
+    return timer(0).pipe(mergeMap(() => {
+        const actions = [resetCreateTransferEntryStatus()];
+        if (previousTransactionId != null) {
+            actions.push(...buildPreviousTransactionCleanupActions(previousTransactionId));
+        }
+        return from(actions);
+    }));
+}
+// ─── Success-path branches ───────────────────────────────────────────────────
+function handleSuccessWithoutTransactionBody(transactionId) {
+    return concat(from(buildSuccessSideEffects(transactionId)), delayedResetAndPreviousCleanup(undefined));
+}
+function handleSuccessWithTransactionBody(transactionPayload, vendorPayload, previousTransactionId, sourceTransactionId) {
+    const newTransactionId = toTransactionID(transactionPayload);
+    const replaced = !transactionIdsAreEqual(previousTransactionId, newTransactionId);
+    const immediate = [
+        updateTransaction(getTransactionDetailKey(newTransactionId), transactionPayload),
+        initializeTransactionDetailLocalData({
+            transactionId: newTransactionId,
+            vendorId: vendorPayload?.[0]?.vendor_id,
+        }),
+        ...buildSuccessSideEffects(sourceTransactionId),
+    ];
+    if (replaced) {
+        immediate.push(createTransferEntryReplacedTransaction(previousTransactionId, newTransactionId));
+    }
+    return concat(from(immediate), delayedResetAndPreviousCleanup(replaced ? previousTransactionId : undefined));
+}
+// ─── Top-level epic ──────────────────────────────────────────────────────────
+const CREATE_TRANSFER_ENTRY_URL = `https://dev.api.zeni.ai/version/accounting/komal/1.0/transactions/transaction-type-update`;
+export const createTransferEntryEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(createTransferEntry.match), mergeMap((action) => {
+    const { transactionId, creditAccountIntegrationId, debitAccountIntegrationId, memo, transactionType, sourceTransactionType, } = action.payload;
+    const previousTransactionId = {
+        id: transactionId,
+        type: sourceTransactionType,
+    };
+    return zeniAPI
+        .postAndGetJSON(CREATE_TRANSFER_ENTRY_URL, {
+        transaction_type: transactionType,
+        transaction_id: transactionId,
+        to_account_integration_id: creditAccountIntegrationId,
+        from_account_integration_id: debitAccountIntegrationId,
+        memo,
+    })
+        .pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response)) {
+            return from(buildFailureActions());
+        }
+        if (response.data?.transaction != null) {
+            return handleSuccessWithTransactionBody(response.data.transaction, response.data.vendors, previousTransactionId, transactionId);
+        }
+        return handleSuccessWithoutTransactionBody(transactionId);
+    }), catchError(() => from(buildFailureActions())));
+}));

package/lib/esm/view/createTransferEntry/epics/fetchTransferAccountsEpic.js

@@ -0,0 +1,36 @@
+import { of } from 'rxjs';
+import { catchError, filter, groupBy, mergeMap, switchMap } from 'rxjs/operators';
+import { updateAccounts } from '../../../entity/account/accountReducer';
+import { isSuccessResponse } from '../../../responsePayload';
+import { fetchAccountsForTransferFlow, updateAccountsForTransferFlow, updateAccountsForTransferFlowFailure, } from '../createTransferEntryReducer';
+const REPORT_ID_BY_TYPE = {
+    transferEntryEligible: 'transfer_accounts',
+    creditCardOnlyEligible: 'credit_card_transfer_accounts',
+};
+const QUERY_BY_TYPE = {
+    transferEntryEligible: { is_only_include_transfer_accounts: true },
+    creditCardOnlyEligible: { is_include_only_credit_card_accounts: true },
+};
+/**
+ * Pools fetched concurrently: `groupBy(kind)` keeps `transferEntryEligible`
+ * and `creditCardOnlyEligible` in their own streams so a back-to-back dispatch
+ * of both does not cancel the first. Within a single type, a fresh dispatch
+ * supersedes any in-flight request (per-group `switchMap`).
+ */
+export const fetchTransferAccountsEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchAccountsForTransferFlow.match), groupBy((action) => action.payload.kind), mergeMap((group$) => group$.pipe(switchMap((action) => {
+    const { kind } = action.payload;
+    const queryValue = QUERY_BY_TYPE[kind];
+    const reportId = REPORT_ID_BY_TYPE[kind];
+    const url = `https://dev.api.zeni.ai/version/accounting/komal/1.0/accounts?query=${encodeURIComponent(JSON.stringify(queryValue))}`;
+    return zeniAPI.getJSON(url).pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const accountIds = response.data.accounts.map((account) => account.account_id);
+            const actions = [
+                updateAccounts(response.data.accounts, reportId),
+                updateAccountsForTransferFlow({ accountIds, kind }),
+            ];
+            return of(...actions);
+        }
+        return of(updateAccountsForTransferFlowFailure({ kind }));
+    }), catchError(() => of(updateAccountsForTransferFlowFailure({ kind }))));
+}))));

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

@@ -4,6 +4,7 @@ import { toMonthYearPeriodId, } from '../../../../commonStateTypes/timePeriod';
 import { getIsAccountingProjectsEnabled } from '../../../../entity/tenant/tenantSelector';
 import { fetchAccountList } from '../../../accountList/accountListReducer';
 import { fetchClassList } from '../../../classList/classListReducer';
+import { fetchAccountsForTransferFlow } from '../../../createTransferEntry/createTransferEntryReducer';
 import { fetchOwnerList } from '../../../ownerList/ownerListReducer';
 import { fetchProjectList } from '../../../projectList/projectListReducer';
 import { fetchTransactionCategorization, fetchTransactionCategorizationView, } from '../../reducers/transactionsViewReducer';
@@ -23,6 +24,13 @@ export const fetchTransactionCategorizationViewEpic = (actions$, state$) => acti
         accountList.fetchState === 'Not-Started') {
         updateActions.push(fetchAccountList('accountList', true));
     }
+    const { transferEntryEligible, creditCardOnlyEligible } = state$.value.createTransferEntryState.transferAccountsByType;
+    if (transferEntryEligible.fetchState === 'Not-Started') {
+        updateActions.push(fetchAccountsForTransferFlow({ kind: 'transferEntryEligible' }));
+    }
+    if (creditCardOnlyEligible.fetchState === 'Not-Started') {
+        updateActions.push(fetchAccountsForTransferFlow({ kind: 'creditCardOnlyEligible' }));
+    }
     const classList = state$.value.classListState;
     if (classList.hasValidState() === false &&
         classList.fetchState === 'Not-Started') {

package/lib/esm/view/expenseAutomationView/helpers/transactionCategorizationLocalDataHelper.js

@@ -59,22 +59,6 @@ export const filterAutoTabLineItems = (tabView, transactionId, updatedTransactio
     }
 };
 export const MAX_SELECTION_LIMIT = 5;
-// Returns true when the transaction should be auto-added to the
-// selectedCheckBoxTransactionIds list after a categorization-related
-// state mutation: all line items are filled, the selection limit has
-// not been hit, and the id isn't already in the list. Consolidates the
-// triplet that was inlined at four sites (updateSelectedCustomer/Vendor,
-// setAllItemsToCategoryClassInLocalDataForCategorization, and
-// setEntityRecommendationForLineIdInLocalData below).
-export const shouldAutoSelectAndAdd = (transaction, localData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) => {
-    if (selectedCheckBoxTransactionIds.includes(transaction.id)) {
-        return false;
-    }
-    if (selectedCheckBoxTransactionIds.length >= MAX_SELECTION_LIMIT) {
-        return false;
-    }
-    return checkIfAllLineItemsAreCategoryClassFilled(transaction, localData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
-};
 export const toTransactionDetailLocalData = (transaction, selectedTab, lineItemsByTransactionIds, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled) => {
     const transactionLocal = {
         ...initialSupportedTransactionCategorization.transactionReviewLocalData,
@@ -560,14 +544,10 @@ export const setEntityRecommendationForLineIdInLocalData = (draft, transaction,
         selectedEntity: transactionDetailLocalData.selectedEntity,
         tabSpecificLineItems: transactionDetailLocalData.tabSpecificLineItems,
     };
-    // Auto-uncheck if not all line items are filled (the row's
-    // category/class became stale after the entity update). Otherwise
-    // route through shouldAutoSelectAndAdd so the MAX_SELECTION_LIMIT
-    // gate is consistently applied across all auto-add sites.
     if (!checkIfAllLineItemsAreCategoryClassFilled(transaction, newLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
         selectedCheckBoxTransactionIds = selectedCheckBoxTransactionIds.filter((id) => id !== transaction.id);
     }
-    else if (shouldAutoSelectAndAdd(transaction, newLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
+    else if (selectedCheckBoxTransactionIds.includes(transaction.id) === false) {
         selectedCheckBoxTransactionIds.push(transaction.id);
     }
     draft.selectedCheckBoxTransactionIds = selectedCheckBoxTransactionIds;

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

@@ -3,8 +3,9 @@ import recordGet from 'lodash/get';
 import uniq from 'lodash/uniq';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
-import { filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, shouldAutoSelectAndAdd, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
+import { MAX_SELECTION_LIMIT, checkIfAllLineItemsAreCategoryClassFilled, filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
 import { DEFAULT_COMPLETED_SUB_TAB, } from '../types/completedSubTab';
+import { TRANSACTIONS_TABS, } from '../types/transactionsViewState';
 export const initialTransactionTabViewState = {
     saveStatus: {
         fetchState: 'Not-Started',
@@ -420,9 +421,12 @@ const expenseAutomationTransactionsView = createSlice({
                     const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
                         .selectedCheckBoxTransactionIds;
                     if (selectedTransaction != null &&
-                        shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
+                        checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
+                        selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
+                        selectedCheckBoxTransactionIds.includes(transactionId) === false) {
                         draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                            ...selectedCheckBoxTransactionIds,
+                            ...draft.transactionCategorizationView[selectedTab]
+                                .selectedCheckBoxTransactionIds,
                             transactionId,
                         ];
                     }
@@ -505,26 +509,9 @@ const expenseAutomationTransactionsView = createSlice({
                 const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                     .transactionReviewLocalDataById, transactionId.id, undefined);
                 if (transactionLocalData != null) {
-                    const newLocalData = setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
-                    // Release the per-line fetch flag for every line this fetch
-                    // covered. Done in-place on the freshly returned local data
-                    // (the helper produces a new mutable object), before we write
-                    // it back to the draft.
-                    lineIds.forEach((lineId) => {
-                        const lineItem = newLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            newLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
                     draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
                         transactionId: transaction.id,
-                        transactionReviewLocalData: newLocalData,
+                        transactionReviewLocalData: setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled),
                     };
                     // Mark transaction as dirty (autofill happened)
                     if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transaction.id)) {
@@ -537,99 +524,6 @@ const expenseAutomationTransactionsView = createSlice({
                 }
             },
         },
-        // Start arm of the line-update recommendations fetch. Flips covered
-        // lines to In-Progress AND removes the transaction from
-        // selectedCheckBoxTransactionIds — the row is unchecked + disabled
-        // until either the success arm (recheck if limit allows) or the
-        // failure arm releases the per-line flag.
-        markCategoryClassRecommendationsInProgressForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const tab = draft.transactionCategorizationView[selectedTab];
-                const transactionLocalData = recordGet(tab.transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'In-Progress',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-                // Uncheck on fetch start: the row's existing category/class are
-                // stale after a payee change, so we drop the auto-selection until
-                // fresh recommendations land.
-                if (tab.selectedCheckBoxTransactionIds.includes(transactionId.id)) {
-                    tab.selectedCheckBoxTransactionIds =
-                        tab.selectedCheckBoxTransactionIds.filter((id) => id !== transactionId.id);
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Completed arm. Used by the epic when the HTTP call succeeds but the
-        // server returned no per-line recommendations — we still need to
-        // release the In-Progress flag so the skeleton resolves. Successful
-        // responses with recommendations go through
-        // setEntityRecommendationForLineIdsForCategorization instead (which
-        // also flips the lines to Completed).
-        markCategoryClassRecommendationsCompletedForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Completed',
-                                    error: undefined,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds) {
-                return { payload: { selectedTab, transactionId, lineIds } };
-            },
-        },
-        // Failure arm. Flips covered lines to Error so the skeleton resolves
-        // and downstream UI can react to the failure. The transaction stays
-        // unchecked from the start-arm action.
-        markCategoryClassRecommendationsFailureForCategorization: {
-            reducer(draft, action) {
-                const { selectedTab, transactionId, lineIds, error } = action.payload;
-                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
-                    .transactionReviewLocalDataById, transactionId.id, undefined);
-                if (transactionLocalData != null) {
-                    lineIds.forEach((lineId) => {
-                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
-                        if (lineItem != null) {
-                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
-                                ...lineItem,
-                                categoryClassRecommendationsFetchState: {
-                                    fetchState: 'Error',
-                                    error,
-                                },
-                            };
-                        }
-                    });
-                }
-            },
-            prepare(selectedTab, transactionId, lineIds, error) {
-                return { payload: { selectedTab, transactionId, lineIds, error } };
-            },
-        },
         fetchTransactionCategorizationSuccess(draft, action) {
             const { selectedTab, refreshViewInBackground } = action.payload;
             if (draft.transactionCategorizationView[selectedTab].fetchState ===
@@ -725,7 +619,9 @@ const expenseAutomationTransactionsView = createSlice({
                     .selectedCheckBoxTransactionIds;
                 if (newTransactionLocalData.customer != null &&
                     newTransactionLocalData.customer.id != null &&
-                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
+                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
+                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
+                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
                     draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
                         ...selectedCheckBoxTransactionIds,
                         transactionId,
@@ -799,7 +695,9 @@ const expenseAutomationTransactionsView = createSlice({
                     .selectedCheckBoxTransactionIds;
                 if (newTransactionLocalData.vendor != null &&
                     newTransactionLocalData.vendor.id != null &&
-                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
+                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
+                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
+                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
                     draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
                         ...selectedCheckBoxTransactionIds,
                         transactionId,
@@ -1030,7 +928,18 @@ const expenseAutomationTransactionsView = createSlice({
                 };
             },
         },
+        removeTransactionFromAllTabs: {
+            prepare(transactionId) {
+                return { payload: { transactionId } };
+            },
+            reducer(draft, action) {
+                const { transactionId } = action.payload;
+                for (const tab of TRANSACTIONS_TABS) {
+                    removeTransactionFromTabView(draft.transactionCategorizationView[tab], transactionId);
+                }
+            },
+        },
     },
 });
-export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, markCategoryClassRecommendationsInProgressForCategorization, markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
+export const { fetchTransactionCategorization, updateTransactionCategorizationUIState, initializeTransactionCategorizationViewLocalData, saveTransactionCategorizationLocalData, fetchTransactionCategorizationFailure, saveTransactionCategorization, updateTransactionCategorization, updateCurrentSelectedTransactionCategorizationTab, updateTransactionCategorizationCompletedSubTab, updateTransactionCategorizationSaveStatus, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateSelectedVendorForTransaction, updateSelectedCustomerForTransaction, setAllItemsToCategoryClassInLocalDataForCategorization, updateTotalCountForTransactionCategorization, updateParentTotalCountForTab, fetchTransactionCategorizationSuccess, resetOtherTabsFetchState, fetchTransactionCategorizationView, updateSelectedCheckboxTransactionIds, clearExpenseAutomationTransactionsViewPerTabView, clearExpenseAutomationTransactionsView, setEntityRecommendationForLineIdsForCategorization, updateSelectedTransactionId, syncTransactionCategorizationFromDetailSave, backgroundRefetchReviewTab, removeTransactionFromAllTabs, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;