@zeniai/client-epic-state 4.19.52 → 4.19.53-betaAR1

package/lib/view/spendManagement/spendManagementFilterHelpers.d.ts

@@ -1,15 +1,22 @@
+import { Amount } from '../../commonStateTypes/amount';
+import { ID } from '../../commonStateTypes/common';
 import { TimePeriod } from '../../commonStateTypes/timePeriod';
+import { TransactionType } from '../../entity/transaction/stateTypes/transactionType';
+import { SupportedTransactionWithCOT } from '../../entity/transaction/transactionState';
 import { UserRoleType } from '../../entity/userRole/userRoleType';
 import { RootState } from '../../reducer';
 import { ZeniDate } from '../../zeniDayJS';
+import { TransactionReviewLocalDataSelectorView } from '../expenseAutomationView/selectorTypes/transactionsViewSelectorTypes';
 import { TaskListFilterCategoryField, TaskListFilters } from '../taskManager/taskListView/taskList';
 import { TaskWithUserDetails } from '../taskManager/taskListView/taskListSelector';
 import { BillTransactionView } from './billPay/billList/billListSelector';
 import { BillListViewFilterCategoryField, BillPayFilters } from './billPay/billList/billListState';
+import { PaymentHistoryFilterCategoryDropdownOption, PaymentHistoryFilters } from './chargeCards/chargeCardPaymentHistory/chargeCardPaymentHistory';
+import { ChargeCardRepaymentWithUser } from './chargeCards/chargeCardPaymentHistory/chargeCardPaymentHistorySelector';
 import { ReimbursementView } from './reimbursement/remiListView/remiListSelector';
 import { ReimbursementFilters, RemiListViewFilterCategoryField } from './reimbursement/remiListView/remiListState';
-export type SpendManagementFiltersType = BillPayFilters | ReimbursementFilters | TaskListFilters;
-export type SpendManagementFilterEntityType = 'bill_pay' | 'reimbursement' | 'task_management';
+export type SpendManagementFiltersType = BillPayFilters | ReimbursementFilters | TaskListFilters | TransactionFilters | PaymentHistoryFilters;
+export type SpendManagementFilterEntityType = 'bill_pay' | 'reimbursement' | 'task_management' | 'transaction_categorization' | 'charge_card_payment_history';
 export type FilterCategoryType = 'searchAutocomplete' | 'user' | 'dateRange' | 'numberRange' | 'dropdown';
 export interface MatchingOperatorDropdownOption {
     label: 'is' | 'is not';
@@ -31,9 +38,45 @@ export interface TaskFilterCategoryDropdownOption {
     multiple?: boolean;
     type?: FilterCategoryType;
 }
-export type SpendManagementFilterCategoryDropdownOption = BillPayFilterCategoryDropdownOption | ReimbursementFilterCategoryDropdownOption | TaskFilterCategoryDropdownOption;
+export type SpendManagementFilterCategoryDropdownOption = BillPayFilterCategoryDropdownOption | ReimbursementFilterCategoryDropdownOption | TaskFilterCategoryDropdownOption | TransactionFilterCategoryDropdownOption | PaymentHistoryFilterCategoryDropdownOption;
+export interface TransactionFilterCategoryDropdownOption {
+    value: TransactionFilterCategoryField;
+    multiple?: boolean;
+    type?: FilterCategoryType;
+}
+export type TransactionFilterEntityType = 'transaction_categorization' | 'customer' | 'vendor' | 'merchant';
+export type TransactionFilterCategoryField = 'payment_account_name' | 'payment_account_type' | 'payee' | 'category' | 'class' | 'amount';
+export declare const TRANSACTION_FILTER_CATEGORIES: TransactionFilterCategoryDropdownOption[];
+export interface TransactionFilters {
+    categories: TransactionFilterCategory[];
+    categoryCombinationOperator: CategoryCombinationOperator;
+}
+/** Amount filter operators for transaction_categorization (expense automation). Other entities use only equal/not-equal. */
+export type TransactionFilterAmountMatchingOperator = 'equal' | 'not-equal' | 'lessThan' | 'greaterThan' | 'inBetween';
+export interface TransactionFilterCategory {
+    field: TransactionFilterCategoryField;
+    matchingOperator: TransactionFilterAmountMatchingOperator;
+    values: (string | ZeniDate)[];
+    valuesCombinationOperator: 'ANY';
+}
+export interface TransactionView {
+    amount: Amount;
+    createTime: ZeniDate;
+    date: ZeniDate;
+    description: string;
+    id: ID;
+    memo: string;
+    transaction: SupportedTransactionWithCOT;
+    type: TransactionType;
+    customerId?: ID;
+    customerName?: string;
+    transactionLocalData?: TransactionReviewLocalDataSelectorView;
+    typeName?: string;
+    vendorId?: ID;
+    vendorName?: string;
+}
 export type FilterCategoryValueType = string | number | ZeniDate;
-export declare const applyAdvancedFiltersOnList: (entity: SpendManagementFilterEntityType, allItems: BillTransactionView[] | ReimbursementView[] | TaskWithUserDetails[], filters?: BillPayFilters | ReimbursementFilters | TaskListFilters, filteredItems?: (BillTransactionView | ReimbursementView | TaskWithUserDetails)[], index?: number) => (BillTransactionView | ReimbursementView | TaskWithUserDetails)[];
+export declare const applyAdvancedFiltersOnList: (entity: SpendManagementFilterEntityType, allItems: BillTransactionView[] | ReimbursementView[] | TaskWithUserDetails[] | TransactionView[] | ChargeCardRepaymentWithUser[], filters?: BillPayFilters | ReimbursementFilters | TaskListFilters | TransactionFilters | PaymentHistoryFilters, filteredItems?: (BillTransactionView | ReimbursementView | TaskWithUserDetails | TransactionView | ChargeCardRepaymentWithUser)[], index?: number) => (BillTransactionView | ReimbursementView | TaskWithUserDetails | TransactionView | ChargeCardRepaymentWithUser)[];
 export declare const isBillListDownloadable: (state: RootState, currentTimePeriod: TimePeriod) => boolean;
 export declare const isRemiListDownloadable: (state: RootState, currentTimePeriod: TimePeriod) => boolean;
 export declare const hideCreatedByFilter: (userRole: UserRoleType[]) => boolean;

package/lib/view/spendManagement/spendManagementFilterHelpers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hideCreatedByFilter = exports.isRemiListDownloadable = exports.isBillListDownloadable = exports.applyAdvancedFiltersOnList = void 0;
+exports.hideCreatedByFilter = exports.isRemiListDownloadable = exports.isBillListDownloadable = exports.applyAdvancedFiltersOnList = exports.TRANSACTION_FILTER_CATEGORIES = void 0;
 const get_1 = __importDefault(require("lodash/get"));
 const userSelector_1 = require("../../entity/user/userSelector");
 const userRoleType_1 = require("../../entity/userRole/userRoleType");
@@ -13,28 +13,81 @@ const billListState_1 = require("./billPay/billList/billListState");
 const helpers_1 = require("./helpers");
 const remiListSelector_1 = require("./reimbursement/remiListView/remiListSelector");
 const remiListState_1 = require("./reimbursement/remiListView/remiListState");
+exports.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') {
-        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;
+        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 {
-        const currentValue = valueForItem;
-        const lowerValue = currentFilter.values[0];
-        const higherValue = currentFilter.values[1];
-        if (currentValue.isSameOrAfter(lowerValue) &&
-            currentValue.isSameOrBefore(higherValue)) {
-            doesItemFallInValueRange = true;
+        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;
+                }
+            }
+        }
+        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;
     }
     return currentFilter.matchingOperator === 'equal'
         ? doesItemFallInValueRange
@@ -72,10 +125,17 @@ const filterItemOnCategoriesWithMultipleValues = (categoryValue, currentFilter)
         return true;
     }
 };
+const getItemId = (item) => {
+    if ('cardRepaymentId' in item) {
+        return item.cardRepaymentId;
+    }
+    return item
+        .id;
+};
 const removeDuplicatesFromList = (list) => {
     const foundIds = [];
     return list.filter((item) => {
-        const itemId = item.id;
+        const itemId = getItemId(item);
         if (foundIds.indexOf(itemId) === -1) {
             foundIds.push(itemId);
             return true;
@@ -110,7 +170,13 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
             ? getCategoryValueForBill(key, item)
             : entity === 'reimbursement'
                 ? getCategoryValueForReimbursement(key, item)
-                : getCategoryValueForTaskList(key, item);
+                : entity === 'task_management'
+                    ? getCategoryValueForTaskList(key, item)
+                    : entity === 'transaction_categorization'
+                        ? getCategoryValueForTransaction(key, item)
+                        : entity === 'charge_card_payment_history'
+                            ? getCategoryValueForPaymentHistory(key, item)
+                            : undefined;
         if (categoryValue == null) {
             if (currentFilter.matchingOperator === 'not-equal') {
                 return true;
@@ -130,6 +196,7 @@ const applyAdvancedFiltersOnList = (entity, allItems, filters, filteredItems = [
                 'dueDate',
                 'creationDate',
                 'receiptDate',
+                'repaymentDate',
             ]);
         }
     });
@@ -231,6 +298,149 @@ 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': {
+            // Get from transaction.account or from lines
+            if (transaction.transaction.account?.accountName) {
+                return transaction.transaction.account.accountName;
+            }
+            // Get from first line's account
+            const firstLine = transaction.transaction.lines?.[0];
+            if (firstLine?.type === 'transaction_with_account_and_class_line' ||
+                firstLine?.type === 'transaction_with_product_or_service_line' ||
+                firstLine?.type === 'journal_entry_transaction_line') {
+                const accountLine = firstLine;
+                return accountLine.account?.accountName;
+            }
+            return undefined;
+        }
+        case 'payment_account_type': {
+            // Similar to payment_account_name but for type
+            if (transaction.transaction.account?.accountType) {
+                return transaction.transaction.account.accountType;
+            }
+            const firstLineForType = transaction.transaction.lines?.[0];
+            if (firstLineForType?.type === 'transaction_with_account_and_class_line' ||
+                firstLineForType?.type === 'transaction_with_product_or_service_line' ||
+                firstLineForType?.type === 'journal_entry_transaction_line') {
+                const accountLineForType = firstLineForType;
+                return accountLineForType.account?.accountType;
+            }
+            return undefined;
+        }
+        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':
+            return repayment.repaymentDate;
+        case 'sourceAccount': {
+            return repayment.paymentAccountId;
+        }
+        case 'status':
+            return repayment.status;
+        case 'initiatedBy':
+            return repayment.repaymentType === 'scheduled'
+                ? 'autopay'
+                : repayment.paidById;
+        default:
+            return undefined;
+    }
+};
 const isBillListDownloadable = (state, currentTimePeriod) => {
     const { billListState, billTransactionState, entityApprovalStatusState, userState, } = state;
     const keys = billListState_1.ALL_BILL_TABS.filter((tab) => tab !== 'draft').map((tab) => (0, billListState_1.getBillListKey)(currentTimePeriod, tab));

package/lib/view/spendManagement/zeniAccounts/depositAccountList/fetchDepositAccountListEpic.js

@@ -11,11 +11,13 @@ const fetchDepositAccountListEpic = (actions$, _state$, zeniAPI) => actions$.pip
     return zeniAPI
         .getJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/deposit-accounts?query=${encodeURIComponent(`{"is_include_deposit_accounts_summary":true}`)}`)
         .pipe((0, operators_1.mergeMap)((response) => {
-        if ((0, responsePayload_1.isSuccessResponse)(response)) {
-            return (0, rxjs_1.of)((0, depositAccountReducer_1.updateDepositAccounts)(response.data?.deposit_accounts ?? []), (0, zeniAccountListReducer_1.updateZeniAccountsSummary)({
+        const isSuccess = (0, responsePayload_1.isSuccessResponse)(response);
+        if (isSuccess) {
+            const depositAccounts = response.data?.deposit_accounts ?? [];
+            return (0, rxjs_1.of)((0, depositAccountReducer_1.updateDepositAccounts)(depositAccounts), (0, zeniAccountListReducer_1.updateZeniAccountsSummary)({
                 summaryPayload: response.data?.all_deposit_accounts_summary,
             }), (0, depositAccountListReducer_1.updateDepositAccountList)({
-                data: response.data?.deposit_accounts ?? [],
+                data: depositAccounts,
                 updateType: 'replace',
             }));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zeniai/client-epic-state",
-  "version": "4.19.52",
+  "version": "4.19.53-betaAR1",
   "description": "Shared module between Web & Mobile containing required abstractions for state management, async network communication. ",
   "main": "lib/index.js",
   "module": "lib/esm/index.js",