@zeniai/client-epic-state 5.0.31-betaAR9 → 5.0.31-betaML1

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

@@ -1,35 +1,20 @@
 import omit from 'lodash/omit';
 import { reduceAllFetchState, reduceAnyFetchState, } from '../../../commonStateTypes/reduceFetchState';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { getAccountBase, getAccountBaseForTransferAccounts, } from '../../../entity/account/accountSelector';
 import { getIsAccountingClassesEnabled, getCurrentTenant, } from '../../../entity/tenant/tenantSelector';
 import { getTransactionWithCOT } from '../../../entity/transaction/transactionHelper';
 import { getSupportedTransactionsByIds } from '../../../entity/transaction/transactionSelector';
-import { applyAdvancedFiltersOnList, } from '../../spendManagement/spendManagementFilterHelpers';
 import { getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
-export const toTransactionView = (transaction, transactionLocalData) => {
-    return {
-        id: transaction.id,
-        date: transaction.date,
-        amount: transaction.amount,
-        vendorName: transaction.vendorName,
-        customerName: transaction.customerName,
-        vendorId: transaction.vendorId,
-        customerId: transaction.customerId,
-        description: transaction.description,
-        memo: transaction.memo,
-        type: transaction.type,
-        typeName: transaction.typeName,
-        createTime: transaction.createTime,
-        transaction: transaction,
-        transactionLocalData,
-    };
-};
+export function getLastTransferEntryReplacement(state) {
+    return state.expenseAutomationTransactionsViewState.lastTransferEntryReplacement;
+}
 export function getExpenseAutomationTransactionView(state) {
     const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, transactionState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
     const { selectedTransactionCategorizationTab } = expenseAutomationTransactionsViewState;
-    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, filters, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
+    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, transactionIdsWithUnsavedData, uploadReceiptStatusById, selectedTransactionId, selectedTransactionLineId, } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab];
     const uncategorizedIncomeExpense = getUncategorizedAccounts(accountState, accountListState, 'accountList');
     const accountList = getAccountList(accountState, accountListState, 'accountList');
     const classList = getClassList(classState, classListState);
@@ -46,42 +31,10 @@ export function getExpenseAutomationTransactionView(state) {
         ? transactionIdsBySelectedPeriod[monthYearPeriodId]
         : null;
     const transactionIds = transactionIdsForSelectedPeriod ?? [];
-    const transactions = getSupportedTransactionsByIds(transactionState, transactionIds);
-    const transactionsWithCOT = transactions.map((transaction) => getTransactionWithCOT(transaction));
-    const transactionLocalDataMap = new Map();
-    transactionIds.forEach((transactionId) => {
-        const transactionData = transactionReviewLocalDataById[transactionId];
-        if (transactionData != null) {
-            transactionLocalDataMap.set(transactionId, {
-                transactionId,
-                transactionReviewLocalData: transactionData.transactionReviewLocalData,
-            });
-        }
-    });
-    // Step 2: Convert to TransactionView and apply advanced filters
-    const transactionViews = transactionsWithCOT.map((transaction) => {
-        const localData = transactionLocalDataMap.get(transaction.id);
-        return toTransactionView(transaction, localData);
-    });
-    // Apply advanced filters if they exist
-    const filteredTransactionViews = applyAdvancedFiltersOnList('transaction_categorization', transactionViews, filters);
-    // Convert back to TransactionWithCOT for return
-    const filteredTransactionsWithCOT = filteredTransactionViews.map((view) => view.transaction);
-    // Get transactionLocalData for filtered transactions
-    // Also include transactionLocalData for transactions that don't exist in transactionState
-    // but have local data (to match original behavior)
-    const filteredTransactionIds = new Set(filteredTransactionViews.map((view) => view.id));
-    const filteredTransactionLocalData = transactionIds
+    const transactionLocalData = transactionIds
         .map((transactionId) => {
         const transactionData = transactionReviewLocalDataById[transactionId];
-        if (transactionData == null) {
-            return null;
-        }
-        // Include if transaction is in filtered results, or if transaction doesn't exist in state
-        // (to maintain backward compatibility with tests)
-        const transactionExists = transactions.some((t) => t.id === transactionId);
-        if (filteredTransactionIds.has(transactionId) ||
-            !transactionExists) {
+        if (transactionData != null) {
             return {
                 transactionId,
                 transactionReviewLocalData: transactionData.transactionReviewLocalData,
@@ -89,7 +42,9 @@ export function getExpenseAutomationTransactionView(state) {
         }
         return null;
     })
-        .filter((data) => data != null);
+        .filter((transaction) => transaction != null);
+    const transactions = getSupportedTransactionsByIds(transactionState, transactionIds);
+    const transactionsWithCOT = transactions.map((transaction) => getTransactionWithCOT(transaction));
     const monthEndFetchState = monthYearPeriodId != null
         ? (monthEndCloseChecksViewState.monthEndCloseChecksViewByTenantId[currentTenant.tenantId]?.[monthYearPeriodId] ?? { fetchState: 'Not-Started', error: undefined })
         : { fetchState: 'Not-Started', error: undefined };
@@ -132,11 +87,24 @@ export function getExpenseAutomationTransactionView(state) {
         : [];
     const transactionCompletionStatus = allSteps.find((step) => step.step === 'transaction_categorization')?.completionStatus;
     const completionStatus = transactionCompletionStatus ?? 'incomplete';
+    const transferAccountsFromApi = expenseAutomationTransactionsViewState.transferAccounts.accountIds
+        .map((id) => getAccountBaseForTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    /**
+     * Credit transfer picker uses transfer-account ids from a dedicated fetch. If that list
+     * resolves to nothing while the COA list is loaded, fall back to the full COA list so the
+     * credit dropdown is not empty.
+     */
+    const transferAccountsList = transferAccountsFromApi.length > 0
+        ? transferAccountsFromApi
+        : accountList.accounts
+            .map((a) => getAccountBase(accountState, a.accountId, 'account_list'))
+            .filter((account) => account != null);
     return {
         version: 0,
         fetchState: fetchStatus.fetchState,
         error: fetchStatus.error,
-        transactions: filteredTransactionsWithCOT,
+        transactions: transactionsWithCOT,
         selectedCheckBoxTransactionIds,
         transactionIdsWithUnsavedData,
         uncategorizedAccounts: uncategorizedIncomeExpense,
@@ -145,16 +113,18 @@ export function getExpenseAutomationTransactionView(state) {
         classList: allClasses,
         accountsHierarchyList,
         classHierarchyList,
-        transactionLocalData: filteredTransactionLocalData,
+        transactionLocalData,
         uiState,
         refreshStatus,
         saveStatus,
         markAsNotMiscategorizedStatus,
+        createTransferEntryStatus: expenseAutomationTransactionsViewState.createTransferEntryStatus,
         completionStatus,
         totalCountByTab,
         fetchStateByTransactionTabs: fetchStateByTab,
         uploadReceiptStatusById,
         selectedTransactionId,
         selectedTransactionLineId,
+        transferAccounts: transferAccountsList,
     };
 }

package/lib/esm/view/spendManagement/spendManagementFilterHelpers.js

@@ -7,81 +7,28 @@ import { ALL_BILL_TABS, getBillListKey, } from './billPay/billList/billListState
 import { getActualPaymentDate } from './helpers';
 import { getApproversOrRejectors as getApproversOrRejectorsForReimbursement, } from './reimbursement/remiListView/remiListSelector';
 import { ALL_REMI_TABS, getRemiListKey, } from './reimbursement/remiListView/remiListState';
-export const TRANSACTION_FILTER_CATEGORIES = [
-    { value: 'payment_account_name', type: 'dropdown' },
-    { value: 'payment_account_type', type: 'dropdown' },
-    { value: 'payee', type: 'searchAutocomplete' },
-    { value: 'category', type: 'dropdown' },
-    { value: 'class', type: 'dropdown' },
-    { value: 'amount', type: 'numberRange' },
-];
 //filters items against filter values representing a range. ex: date (from-to), amount(1k<-->5k)
-// For amount: supports new transaction_categorization operators (inBetween, lessThan, greaterThan) and
-// backward compatibility for old format values: ["1000<->5000"] with matchingOperator "equal".
-// Other entities (bill_pay, reimbursement, etc.) use only equal/not-equal and are unchanged.
 const filterItemOnRangeCategoryType = (valueForItem, currentFilter) => {
     let doesItemFallInValueRange = false;
     const filterField = currentFilter.field;
     if (filterField === 'amount') {
-        const currentValue = Number(valueForItem);
-        const op = currentFilter.matchingOperator;
-        const values = currentFilter.values;
-        if (op === 'inBetween') {
-            // New format: values = [min, max] (expense automation transaction_categorization only)
-            if (values.length >= 2) {
-                const min = Number(values[0]);
-                const max = Number(values[1]);
-                doesItemFallInValueRange = currentValue >= min && currentValue <= max;
-            }
-        }
-        else if (op === 'lessThan') {
-            if (values.length >= 1) {
-                const threshold = Number(values[0]);
-                doesItemFallInValueRange = currentValue < threshold;
-            }
-        }
-        else if (op === 'greaterThan') {
-            if (values.length >= 1) {
-                const threshold = Number(values[0]);
-                doesItemFallInValueRange = currentValue > threshold;
-            }
-        }
-        else if (op === 'equal' &&
-            values.length === 1 &&
-            String(values[0]).includes('<->')) {
-            // Backward compatibility: old format ["1000<->5000"] with matchingOperator "equal"
-            const parts = String(values[0]).split('<->');
-            const lowerValue = Number(parts[0] ?? '');
-            const higherValue = Number(parts[1] ?? '');
-            doesItemFallInValueRange =
-                currentValue >= lowerValue && currentValue <= higherValue;
-        }
-        else if (op === 'equal' && values.length === 1) {
-            // New format: exact match on single value (expense automation)
-            const val = Number(values[0]);
-            doesItemFallInValueRange = currentValue === val;
-        }
-        else {
-            // Existing logic for equal/not-equal (bill_pay, reimbursement, etc. or multiple range values)
-            for (const filterValue of values) {
-                const lowerValue = Number.parseInt(filterValue?.toString()?.split('<->')[0] ?? '', 10);
-                const higherValue = Number.parseInt(filterValue?.toString()?.split('<->')[1] ?? '', 10);
-                if (currentValue >= lowerValue && currentValue <= higherValue) {
-                    doesItemFallInValueRange = true;
-                }
+        for (const filterValue of currentFilter.values) {
+            const currentValue = parseInt(valueForItem.toString());
+            const lowerValue = parseInt(filterValue?.toString()?.split('<->')[0] ?? '');
+            const higherValue = parseInt(filterValue?.toString()?.split('<->')[1] ?? '');
+            if (currentValue >= lowerValue && currentValue <= higherValue) {
+                doesItemFallInValueRange = true;
             }
         }
-        return op === 'not-equal'
-            ? !doesItemFallInValueRange
-            : doesItemFallInValueRange;
     }
-    // Date range and other range fields (unchanged for other entities)
-    const currentValue = valueForItem;
-    const lowerValue = currentFilter.values[0];
-    const higherValue = currentFilter.values[1];
-    if (currentValue.isSameOrAfter(lowerValue) &&
-        currentValue.isSameOrBefore(higherValue)) {
-        doesItemFallInValueRange = true;
+    else {
+        const currentValue = valueForItem;
+        const lowerValue = currentFilter.values[0];
+        const higherValue = currentFilter.values[1];
+        if (currentValue.isSameOrAfter(lowerValue) &&
+            currentValue.isSameOrBefore(higherValue)) {
+            doesItemFallInValueRange = true;
+        }
     }
     return currentFilter.matchingOperator === 'equal'
         ? doesItemFallInValueRange
@@ -166,11 +113,7 @@ export const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredIt
                 ? getCategoryValueForReimbursement(key, item)
                 : entity === 'task_management'
                     ? getCategoryValueForTaskList(key, item)
-                    : entity === 'transaction_categorization'
-                        ? getCategoryValueForTransaction(key, item)
-                        : entity === 'charge_card_payment_history'
-                            ? getCategoryValueForPaymentHistory(key, item)
-                            : undefined;
+                    : getCategoryValueForPaymentHistory(key, item);
         if (categoryValue == null) {
             if (currentFilter.matchingOperator === 'not-equal') {
                 return true;
@@ -291,119 +234,6 @@ const getCategoryValueForReimbursement = (key, reimbursement) => {
             return undefined;
     }
 };
-const getCategoryValueForTransaction = (key, transaction) => {
-    switch (key) {
-        case 'amount': {
-            // Get from transactionLocalData line items (preferred) - sum all line item amounts
-            const localDataForAmount = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForAmount?.lineItemById) {
-                const lineItems = Object.values(localDataForAmount.lineItemById);
-                if (lineItems.length > 0) {
-                    // Sum all line item amounts
-                    const totalAmount = lineItems.reduce((sum, lineItem) => sum + (lineItem.amount?.amount ?? 0), 0);
-                    return totalAmount;
-                }
-            }
-            // Fallback to transaction-level amount or sum from transaction lines
-            if (transaction.transaction.lines &&
-                transaction.transaction.lines.length > 0) {
-                const totalAmount = transaction.transaction.lines.reduce((sum, line) => sum + (line.amount?.amount ?? 0), 0);
-                return totalAmount;
-            }
-            // Final fallback to transaction amount
-            return transaction.amount.amount;
-        }
-        case 'payee': {
-            // Priority: vendorName > customerName > from transactionLocalData
-            if (transaction.vendorName) {
-                return transaction.vendorName;
-            }
-            if (transaction.customerName) {
-                return transaction.customerName;
-            }
-            // Check transactionLocalData for vendor/customer
-            const localData = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localData?.vendor?.name) {
-                return localData.vendor.name;
-            }
-            if (localData?.customer?.name) {
-                return localData.customer.name;
-            }
-            return undefined;
-        }
-        case 'payment_account_name': {
-            // Match the value the row renders: TransactionCategorizationListRow reads
-            // `currentTransaction?.account?.accountName` for the Payment Account Name
-            // column. Returning the same field here keeps filter-match parity with the
-            // visible cell, so any row a user can see is also a row the filter can match.
-            return transaction.transaction.account?.accountName;
-        }
-        case 'payment_account_type': {
-            // Compare against the raw `paymentType` enum (e.g. "credit_card", "check",
-            // "cash"). The same enum is what TransactionCategorizationListRow uses for
-            // its icon switch on line ~1675, and it's what the dropdown options emit
-            // as `value`. Display labels come from each account's `paymentTypeName`
-            // field (populated by mapAccountBasePayloadToAccountBase from the backend
-            // payload) — no client-side label map required.
-            return transaction.transaction.paymentType;
-        }
-        case 'category': {
-            // Get from transactionLocalData (preferred) or from transaction lines
-            const localDataForCategory = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForCategory) {
-                // Get category from first line item or most common
-                const firstLineItem = Object.values(localDataForCategory.lineItemById)[0];
-                if (firstLineItem?.account?.accountId) {
-                    return firstLineItem.account.accountId;
-                }
-                if (firstLineItem?.account?.qboId) {
-                    return firstLineItem.account.qboId;
-                }
-                if (firstLineItem?.account?.accountName) {
-                    return firstLineItem.account.accountName;
-                }
-            }
-            // Fallback to transaction lines
-            const firstLineForCategory = transaction.transaction.lines?.[0];
-            if (firstLineForCategory?.type ===
-                'transaction_with_account_and_class_line' ||
-                firstLineForCategory?.type ===
-                    'transaction_with_product_or_service_line' ||
-                firstLineForCategory?.type === 'journal_entry_transaction_line') {
-                const account = firstLineForCategory.account;
-                return account?.accountId ?? account?.qboId ?? account?.accountName;
-            }
-            return undefined;
-        }
-        case 'class': {
-            // Similar to category but for class
-            const localDataForClass = transaction.transactionLocalData?.transactionReviewLocalData;
-            if (localDataForClass) {
-                const firstLineItemForClass = Object.values(localDataForClass.lineItemById)[0];
-                if (firstLineItemForClass?.class?.classId) {
-                    return firstLineItemForClass.class.classId;
-                }
-                if (firstLineItemForClass?.class?.qboId) {
-                    return firstLineItemForClass.class.qboId;
-                }
-                if (firstLineItemForClass?.class?.className) {
-                    return firstLineItemForClass.class.className;
-                }
-            }
-            const firstLineForClass = transaction.transaction.lines?.[0];
-            if (firstLineForClass?.type === 'transaction_with_account_and_class_line' ||
-                firstLineForClass?.type ===
-                    'transaction_with_product_or_service_line' ||
-                firstLineForClass?.type === 'journal_entry_transaction_line') {
-                const classData = firstLineForClass.class;
-                return classData?.classId ?? classData?.qboId ?? classData?.className;
-            }
-            return undefined;
-        }
-        default:
-            return undefined;
-    }
-};
 const getCategoryValueForPaymentHistory = (key, repayment) => {
     switch (key) {
         case 'repaymentDate':

package/lib/esm/view/transactionDetail/epics/transactionDetailEpic.js

@@ -13,6 +13,7 @@ import { fetchAccountList } from '../../accountList/accountListReducer';
 import { fetchClassList } from '../../classList/classListReducer';
 import { getInitializedTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorLocalDataHelper';
 import { updateTransactionVendorLocalData } from '../../commonVendorView/transactionVendorView/transactionVendorViewReducer';
+import { fetchTransferAccounts } from '../../expenseAutomationView/reducers/transactionsViewReducer';
 import { fetchOwnerList } from '../../ownerList/ownerListReducer';
 import { fetchTransactionDetail, initializeTransactionDetailLocalData, removeTransactionDetail, updateTransactionDetailFetchState, } from '../transactionDetailReducer';
 import { getAllLinkedTransactions, getTransactionDetailKey, } from '../transactionDetailState';
@@ -34,6 +35,11 @@ export const fetchTransactionDetailEpic = (actions$, state$, zeniAPI) => actions
             accountList.fetchState !== 'In-Progress') {
             transactionActions.push(fetchAccountList('accountList'));
         }
+        const { transferAccounts } = state$.value.expenseAutomationTransactionsViewState;
+        if (transferAccounts.fetchState !== 'In-Progress' &&
+            transferAccounts.fetchState !== 'Completed') {
+            transactionActions.push(fetchTransferAccounts());
+        }
         const classList = state$.value.classListState;
         if (classList.hasValidState() === false &&
             classList.fetchState !== 'In-Progress') {

package/lib/esm/view/transactionDetail/transactionDetailSelector.js

@@ -1,5 +1,6 @@
 import recordGet from 'lodash/get';
 import { reduceFetchState } from '../../commonStateTypes/reduceFetchState';
+import { getAccountBase, getAccountBaseForTransferAccounts, } from '../../entity/account/accountSelector';
 import { getIsAccountingClassesEnabled } from '../../entity/tenant/tenantSelector';
 import { toTransactionTypeStrict } from '../../entity/transaction/stateTypes/transactionType';
 import { getTransactionWithCOT } from '../../entity/transaction/transactionHelper';
@@ -10,7 +11,7 @@ import { getAccountList, getNestedAccountListHierarchy, } from '../accountList/a
 import { getClassList, getNestedClassListHierarchy, } from '../classList/classListSelector';
 import { getAllLinkedTransactions, getTransactionDetailKey, initialSupportedTransactionDetail, } from './transactionDetailState';
 export const getTransactionDetail = (state, transactionId, fetchLinkedTransactions = true) => {
-    const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, } = state;
+    const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, } = state;
     const detailKey = getTransactionDetailKey(transactionId);
     const transactionDetail = recordGet(transactionDetailState.transactionDetailById, detailKey);
     let fetchState = {
@@ -62,6 +63,14 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
         : [];
     const transactionDetailAnyUpdateStatus = reduceUpdateFetchStates(transactionDetail);
     const vendors = getVendorsByVendorIds(vendorState, vendorListState.vendorIds);
+    const transferAccountsFromApi = expenseAutomationTransactionsViewState.transferAccounts.accountIds
+        .map((id) => getAccountBaseForTransferAccounts(accountState, id))
+        .filter((account) => account != null);
+    const transferAccountsList = transferAccountsFromApi.length > 0
+        ? transferAccountsFromApi
+        : accountsList.accounts
+            .map((a) => getAccountBase(accountState, a.accountId, 'account_list'))
+            .filter((account) => account != null);
     return {
         reportId: 'transaction_detail',
         reportTitle: 'Transaction Detail',
@@ -78,6 +87,8 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
         accountsHierarchyList,
         classList: classList,
         isAccountingClassesEnabled,
+        createTransferEntryStatus: expenseAutomationTransactionsViewState.createTransferEntryStatus,
+        transferAccounts: transferAccountsList,
         isUpdateNotAllowed: transactionDetail?.isUpdateNotAllowed,
         transactionDetailLocalData: transactionDetail?.transactionDetailLocalData ??
             initialSupportedTransactionDetail.transactionDetailLocalData,