@zeniai/client-epic-state 5.2.62-beta0MM → 5.2.62-beta1KB

package/lib/esm/view/spendManagement/billPay/editBillView/editBillViewSelector.js

@@ -625,7 +625,7 @@ export const getDueDate = (billStageCode, dueDate, invoiceDate, bookCloseDate) =
     }
 };
 export const getWithdrawFrom = (state, fromAccountId, fromAccountType, companyId, lastSelectedFromAccount) => {
-    const { paymentAccountState, depositAccountState, depositAccountListState, paymentAccountListState, } = state;
+    const { paymentAccountState, depositAccountState, paymentAccountListState } = state;
     if (fromAccountId != null) {
         const withdrawFromAsDepositAcc = getDepositAccountByDepositAccountId(depositAccountState, fromAccountId);
         const withdrawFromAsPaymentAcc = getPaymentAccountByPaymentAccountId(paymentAccountState, fromAccountId);
@@ -639,41 +639,15 @@ export const getWithdrawFrom = (state, fromAccountId, fromAccountType, companyId
         }
     }
     else {
-        return getDefaultWithdrawFromAccount(state, depositAccountListState.accountIds, companyId ?? '', lastSelectedFromAccount);
+        return getDefaultWithdrawFromAccount(state, companyId ?? '', lastSelectedFromAccount);
     }
     return undefined;
 };
-export const getDefaultWithdrawFromAccount = (state, depositAccounts, companyId, lastSelectedFromAccount) => {
+export const getDefaultWithdrawFromAccount = (state, companyId, lastSelectedFromAccount) => {
     const { depositAccountState, paymentAccountState, paymentAccountListState } = state;
     const companyView = getCompanyView(state, companyId, []);
     const primaryAccount = companyView?.company.company.companyBillPayInfo.primaryFundingAccount;
-    let defaultAccount = undefined;
-    // User paying bill for first time or previously paid with external account
-    if (lastSelectedFromAccount == null ||
-        lastSelectedFromAccount?.accountType === 'paymentAccount') {
-        if (depositAccounts.length === 0) {
-            defaultAccount = primaryAccount;
-        }
-        else {
-            if (primaryAccount?.accountType === 'depositAccount') {
-                defaultAccount = primaryAccount;
-            }
-        }
-    }
-    else {
-        // User paid with Zeni account previously
-        if (depositAccounts.length === 1) {
-            defaultAccount = lastSelectedFromAccount;
-        }
-        else {
-            if (primaryAccount?.accountType === 'depositAccount') {
-                defaultAccount = primaryAccount;
-            }
-            else {
-                defaultAccount = lastSelectedFromAccount;
-            }
-        }
-    }
+    const defaultAccount = primaryAccount ?? lastSelectedFromAccount;
     if (defaultAccount != null) {
         const defaultAccAsDepositAcc = getDepositAccountByDepositAccountId(depositAccountState, defaultAccount?.accountId);
         const defaultAccAsPaymentAcc = getPaymentAccountByPaymentAccountId(paymentAccountState, defaultAccount?.accountId);

package/lib/esm/view/transactionDetail/createTransaction/createTransactionLocalDataHelper.js

@@ -0,0 +1,133 @@
+import { dateNow } from '../../../zeniDayJS';
+import { ALL_CREATABLE_TRANSACTION_TYPES, } from './createTransactionState';
+/**
+ * Monotonic counter for line row keys. These never leave the client -- the payload builder
+ * drops them -- so a counter is enough, and it keeps reducer tests deterministic in a way
+ * randomUUID would not.
+ */
+let lineIdCounter = 0;
+export const nextCreateTransactionLineId = () => `create-transaction-line-${lineIdCounter++}`;
+/** Test-only: makes line ids predictable from the start of each case. */
+export const resetCreateTransactionLineIdCounter = () => {
+    lineIdCounter = 0;
+};
+export const createEmptyCreateTransactionLine = (postingType) => ({
+    id: nextCreateTransactionLineId(),
+    postingType,
+});
+/**
+ * The lines a freshly-opened form starts with. A journal entry is invalid with fewer than one
+ * debit and one credit, so it opens with both rather than making the user add the second row.
+ * Transfer has no lines at all.
+ */
+export const getDefaultCreateTransactionLines = (transactionType) => {
+    if (transactionType === 'transfer') {
+        return [];
+    }
+    if (transactionType === 'journal_entry') {
+        return [
+            createEmptyCreateTransactionLine('debit'),
+            createEmptyCreateTransactionLine('credit'),
+        ];
+    }
+    return [createEmptyCreateTransactionLine()];
+};
+/**
+ * A blank working copy for one type. Note this does NOT seed the date -- the reducer's initial
+ * state has to stay a pure constant so `clearAll` restores something stable. The date is seeded
+ * by initializeCreateTransactionLocalDataEpic, which runs when the form opens.
+ */
+export const getEmptyCreateTransactionLocalData = (transactionType) => ({
+    lines: [],
+    transactionType,
+});
+export const getInitialCreateTransactionLocalDataByType = () => ALL_CREATABLE_TRANSACTION_TYPES.reduce((acc, transactionType) => {
+    acc[transactionType] =
+        getEmptyCreateTransactionLocalData(transactionType);
+    return acc;
+}, {});
+/**
+ * What the form opens with: a blank copy plus today's date, the default line set, and the one
+ * payment_type the backend insists on for a check (qbo_purchase.py raises without it).
+ */
+export const getSeededCreateTransactionLocalData = (transactionType) => ({
+    ...getEmptyCreateTransactionLocalData(transactionType),
+    lines: getDefaultCreateTransactionLines(transactionType),
+    paymentType: transactionType === 'check' ? 'check' : undefined,
+    transactionDate: dateNow(),
+});
+/**
+ * Merges a partial edit into the working copy. Lines are replaced wholesale when present --
+ * a partial line array would silently truncate the form.
+ */
+export const mergeCreateTransactionLocalData = (current, update) => ({
+    ...current,
+    ...update,
+    lines: update.lines ?? current.lines,
+    // The type is keyed by the slice, never edited through a merge.
+    transactionType: current.transactionType,
+});
+export const updateCreateTransactionLine = (lines, lineId, update) => lines.map((line) => line.id === lineId ? { ...line, ...update, id: line.id } : line);
+/**
+ * Recommendation -> RecommendationWithCOT. Chain-of-thought and recommendation feedback both
+ * need an existing transaction, so cot/reasoning are empty here by design; the dropdown only
+ * needs the entities to build its "Recommended" group.
+ */
+export const toRecommendationsWithCOT = (recommendations) => recommendations.map((recommendation) => ({
+    account: recommendation.account != null
+        ? { ...recommendation.account, cot: [], reasoning: '' }
+        : undefined,
+    class: recommendation.class != null
+        ? { ...recommendation.class, cot: [], reasoning: '' }
+        : undefined,
+    vendor: recommendation.vendor != null
+        ? { ...recommendation.vendor, cot: [], reasoning: '' }
+        : undefined,
+}));
+/**
+ * Applies a vendor's recommendations to one line: always refreshes the dropdown's "Recommended"
+ * group, but only prefills account/class when the field is still empty. Anything the user
+ * picked wins -- this follows the transaction-categorization helper, which prefills, rather
+ * than the detail-page helper, which only suggests.
+ */
+export const applyRecommendationsToCreateTransactionLine = (line, recommendations, isAccountingClassesEnabled) => {
+    const top = recommendations[0];
+    const updated = {
+        ...line,
+        recommendationsWithCOT: toRecommendationsWithCOT(recommendations),
+    };
+    if (line.accountQboId == null && top?.account?.qboId != null) {
+        updated.accountQboId = top.account.qboId;
+        updated.accountName = top.account.accountName;
+        updated.isAccountPreFilled = true;
+    }
+    if (isAccountingClassesEnabled &&
+        line.classId == null &&
+        top?.class?.classId != null) {
+        updated.classId = top.class.classId;
+        updated.isClassPreFilled = true;
+    }
+    return updated;
+};
+/**
+ * Undoes a prefill when the vendor is cleared. Only the fields the prefill wrote are removed --
+ * the per-field flags are what make the user's own choices distinguishable from ours, which is
+ * why they are not a single line-level boolean: a hand-picked account alongside a prefilled
+ * class is an ordinary state, and clearing must not take the account with it.
+ */
+export const clearRecommendationsFromCreateTransactionLine = (line) => {
+    const cleared = {
+        ...line,
+        recommendationsWithCOT: undefined,
+    };
+    if (line.isAccountPreFilled === true) {
+        cleared.accountQboId = undefined;
+        cleared.accountName = undefined;
+        cleared.isAccountPreFilled = undefined;
+    }
+    if (line.isClassPreFilled === true) {
+        cleared.classId = undefined;
+        cleared.isClassPreFilled = undefined;
+    }
+    return cleared;
+};

package/lib/esm/view/transactionDetail/createTransaction/createTransactionPayload.js

@@ -0,0 +1,124 @@
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { getAccountBase } from '../../../entity/account/accountSelector';
+import { getClassById } from '../../../entity/class/classSelector';
+import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
+const toRemitToAddressPayload = (address) => {
+    if (address == null) {
+        return undefined;
+    }
+    return {
+        line1: address.line1,
+        city: address.city,
+        state: address.state,
+        postal_code: address.postalCode,
+        country: address.country,
+    };
+};
+const toLinePayload = (state, line, transactionType) => {
+    const lineDetail = {};
+    if (line.accountQboId != null) {
+        lineDetail.account = {
+            qbo_id: line.accountQboId,
+            account_name: line.accountName,
+        };
+    }
+    // An empty object is what the confirmed payloads send when no class is chosen; sending the
+    // key with a qbo_id only once one is picked.
+    const classQboId = toQboClassId(state, line.classId);
+    lineDetail.class = classQboId != null ? { qbo_id: classQboId } : {};
+    if (transactionType === 'journal_entry') {
+        lineDetail.posting_type = line.postingType;
+        if (line.vendorQboId != null) {
+            lineDetail.vendor = { qbo_id: line.vendorQboId };
+        }
+    }
+    return {
+        // The backend rejects a bool here, so this is always coerced to a number.
+        amount: line.amount?.amount ?? 0,
+        line_description: line.lineDescription,
+        line_detail_type: transactionType === 'journal_entry'
+            ? 'journal_entry_line_detail'
+            : 'account_based_expense_line_detail',
+        line_detail: lineDetail,
+    };
+};
+/** Resolves a Zeni account id to the QBO id the endpoint expects. */
+const toQboAccountId = (state, accountId) => {
+    if (accountId == null) {
+        return undefined;
+    }
+    return (getAccountBase(state.accountState, accountId, 'account_list')?.qboId ??
+        accountId);
+};
+/** Resolves a Zeni class id (`class_<uuid>`) to the QBO id `line_detail.class.qbo_id` expects. */
+const toQboClassId = (state, classId) => {
+    if (classId == null) {
+        return undefined;
+    }
+    return (getClassById(state.classState, { classId, reportId: 'class_list' })
+        ?.qboId ?? classId);
+};
+/** Resolves a Zeni vendor id to its QBO id -- `vendor_id` on the wire is a QBO id. */
+const toQboVendorId = (state, vendorId) => {
+    if (vendorId == null) {
+        return undefined;
+    }
+    return getVendorByVendorId(state.vendorState, vendorId)?.qboId ?? vendorId;
+};
+/**
+ * Builds the request body for one transaction type. One branch per type rather than a shared
+ * body with optional keys, because the types genuinely diverge -- transfer carries no lines at
+ * all, and journal_entry carries no header account.
+ */
+export const prepareCreateTransactionPayload = (state, localData) => {
+    const { transactionType } = localData;
+    const base = {
+        transaction_type: transactionType,
+        transaction_date: localData.transactionDate?.format(DEFAULT_DATE_FORMAT) ?? '',
+        transaction_memo: localData.transactionMemo,
+    };
+    if (transactionType === 'transfer') {
+        return {
+            ...base,
+            from_account_id: toQboAccountId(state, localData.fromAccountId),
+            to_account_id: toQboAccountId(state, localData.toAccountId),
+            total_amount: localData.totalAmount?.amount ?? 0,
+        };
+    }
+    const lines = localData.lines.map((line) => toLinePayload(state, line, transactionType));
+    if (transactionType === 'journal_entry') {
+        return {
+            ...base,
+            document_id: localData.documentId,
+            lines,
+        };
+    }
+    const purchaseBase = {
+        ...base,
+        payment_type: localData.paymentType,
+        qbo_account_id: toQboAccountId(state, localData.qboAccountId),
+        vendor_id: toQboVendorId(state, localData.vendorId),
+        lines,
+    };
+    if (transactionType === 'check') {
+        return {
+            ...purchaseBase,
+            document_number: localData.documentNumber,
+            print_status: localData.printStatus,
+            remit_to_address: toRemitToAddressPayload(localData.remitToAddress),
+        };
+    }
+    if (transactionType === 'credit_card_credit') {
+        // credit_card_credit is not in the backend's SUPPORTED_TRANSACTION_WRITE_TYPES. QBO models
+        // it as a Purchase with Credit: true and qbo_purchase.py already honours is_credit for
+        // card payment types, so this sends `expense` + is_credit rather than a type the validator
+        // rejects outright. Confirm with backend before enabling the menu item.
+        return {
+            ...purchaseBase,
+            transaction_type: 'expense',
+            is_credit: true,
+            document_number: localData.documentNumber,
+        };
+    }
+    return purchaseBase;
+};

package/lib/esm/view/transactionDetail/createTransaction/createTransactionSelector.js

@@ -0,0 +1,41 @@
+import { getNestedAccountListHierarchy } from '../../accountList/accountListSelector';
+import { getNestedClassListHierarchy } from '../../classList/classListSelector';
+import { getResolvedTransferAccounts } from '../../createTransferEntry/createTransferEntrySelector';
+import { getRecommendationsForEntity } from '../../recommendation/recommendationSelector';
+export const getCreateTransactionLocalData = (state, transactionType) => state.transactionDetailState.createTransactionsState.newTransactionState[transactionType];
+export const getCreateTransactionStatus = (state) => state.transactionDetailState.createTransactionsState.createStatus;
+/**
+ * The vendor recommendations backing the category/class dropdowns on the create page.
+ *
+ * No new state field is needed for this: getRecommendationsForEntity already returns
+ * fetchState alongside recommendations, so composing it here is enough for the page to show a
+ * line skeleton and hold Save while a fetch is in flight.
+ */
+export const getCreateTransactionVendorRecommendations = (state, vendorQboId) => {
+    if (vendorQboId == null || vendorQboId === '') {
+        return { fetchState: 'Not-Started' };
+    }
+    const view = getRecommendationsForEntity(state, vendorQboId, 'vendor');
+    return {
+        fetchState: view.fetchState,
+        recommendations: view.recommendations,
+    };
+};
+export const getCreateTransactionView = (state, transactionType) => {
+    const { accountListState, classListState, transactionDetailState, vendorState, } = state;
+    const { createTransactionsState } = transactionDetailState;
+    return {
+        transactionType,
+        localData: createTransactionsState.newTransactionState[transactionType],
+        createStatus: createTransactionsState.createStatus,
+        createdTransactionId: createTransactionsState.createdTransactionId,
+        vendorList: Object.values(vendorState.vendorByID),
+        accountListNestedAccountHierarchy: getNestedAccountListHierarchy(accountListState, 'accountList'),
+        classListNestedAccountHierarchy: getNestedClassListHierarchy(classListState),
+        transferAccountsList: transactionType === 'transfer'
+            ? getResolvedTransferAccounts(state).transferAccountsList
+            : [],
+        fetchState: createTransactionsState.createStatus.fetchState,
+        error: createTransactionsState.createStatus.error,
+    };
+};

package/lib/esm/view/transactionDetail/createTransaction/createTransactionState.js

@@ -0,0 +1,11 @@
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+export const ALL_CREATABLE_TRANSACTION_TYPES = [
+    'expense',
+    'check',
+    'credit_card_credit',
+    'transfer',
+    'journal_entry',
+];

package/lib/esm/view/transactionDetail/createTransaction/epics/createTransactionEpic.js

@@ -0,0 +1,58 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { toTransactionID } from '../../../../entity/transaction/payloadTypes/transactionIDPayload';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { createTransaction, createTransactionSuccessOrFailure, initializeTransactionDetailLocalData, resetCreateTransactionLocalData, } from '../../transactionDetailReducer';
+import { getTransactionDetailKey } from '../../transactionDetailState';
+import { prepareCreateTransactionPayload, } from '../createTransactionPayload';
+const failureActions = (message, status) => [
+    createTransactionSuccessOrFailure('Error', undefined, status),
+    openSnackbar({
+        messageSection: 'create_transaction',
+        messageText: 'failed',
+        type: 'error',
+        // This variable is how the server's own message reaches the user. Per-type required
+        // fields live in the QBO entity classes, so a rejection comes back as a QBO error with no
+        // field name -- the message text is the only useful content we get.
+        variables: [{ variableName: '_api-error_', variableValue: message }],
+    }),
+];
+export const createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createTransaction.match), mergeMap((action) => {
+    const { transactionType } = action.payload;
+    const state = state$.value;
+    const localData = state.transactionDetailState.createTransactionsState
+        .newTransactionState[transactionType];
+    const payload = prepareCreateTransactionPayload(state, localData);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, payload)
+        .pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response) || response.data == null) {
+            return from(failureActions(response.status.message, response.status));
+        }
+        const created = response.data.transactions[0];
+        if (created == null) {
+            return from(failureActions('Transaction was created but returned no details.', createZeniAPIStatus('Unexpected Error', 'Create transaction returned an empty transactions array.')));
+        }
+        const newTransactionId = toTransactionID(created);
+        // The write is QBO-only: transaction_write_handler.py touches no local storage, and
+        // Zeni's mirror is populated by the delta sync that runs afterwards. Refetching here
+        // would come back without the new row, so the 200 body is inserted optimistically
+        // instead -- the same approach createTransferEntryEpic takes.
+        return from([
+            updateTransaction(getTransactionDetailKey(newTransactionId), created),
+            initializeTransactionDetailLocalData({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            createTransactionSuccessOrFailure('Completed', newTransactionId),
+            resetCreateTransactionLocalData(transactionType),
+            openSnackbar({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), catchError((error) => from(failureActions(JSON.stringify(error), createZeniAPIStatus('Unexpected Error', `Create Transaction REST API call errored out ${JSON.stringify(error)}`)))));
+}));

package/lib/esm/view/transactionDetail/createTransaction/epics/fetchVendorRecommendationsForCreateTransactionEpic.js

@@ -0,0 +1,55 @@
+import { concat, from, of } from 'rxjs';
+import { filter, mergeMap, switchMap, take } from 'rxjs/operators';
+import { getIsAccountingClassesEnabled } from '../../../../entity/tenant/tenantSelector';
+import { fetchRecommendationByEntityId, fetchRecommendationByEntityName, indicateReadyToInitializeRecommendation, } from '../../../recommendation/recommendationReducer';
+import { getRecommendationsForEntity } from '../../../recommendation/recommendationSelector';
+import { clearRecommendationsForCreateTransactionLines, fetchVendorRecommendationsForCreateTransaction, setRecommendationsForCreateTransactionLines, } from '../../transactionDetailReducer';
+/**
+ * The entity-level recommendation fetch, keyed by whatever identifier the endpoint can resolve.
+ *
+ * A vendor that has not synced to QBO carries `qboId === name`; the id endpoint has nothing to
+ * look up in that case, so the by-name variant is used instead.
+ */
+const toEntityIdOrName = (entity) => entity.qboId !== '' && entity.qboId !== entity.name
+    ? entity.qboId
+    : entity.name;
+const isUnsyncedVendor = (entity) => entity.qboId === '' || entity.qboId === entity.name;
+/**
+ * On vendor select, populates the category/class dropdowns from that vendor's recommendations.
+ *
+ * Deliberately NOT the detail page's fetchEntityRecommendationsForLineUpdate: that one sends
+ * transaction_id / line_ids and writes into transactionDetailById[key], which no-ops when the
+ * entry does not exist. A transaction being created has neither.
+ *
+ * Two differences from the reimbursement epic this is modelled on:
+ *  1. the wait filters on the matching entityIdOrName before take(1), so an unrelated
+ *     recommendation landing first cannot satisfy this request, and
+ *  2. switchMap, so changing the vendor again cancels the earlier wait rather than letting a
+ *     stale result overwrite the newer vendor's prefill.
+ */
+export const fetchVendorRecommendationsForCreateTransactionEpic = (actions$, state$) => actions$.pipe(filter(fetchVendorRecommendationsForCreateTransaction.match), switchMap((action) => {
+    const { transactionType, entity, lineIds } = action.payload;
+    if (entity == null) {
+        return of(clearRecommendationsForCreateTransactionLines(transactionType, lineIds));
+    }
+    const entityIdOrName = toEntityIdOrName(entity);
+    const state = state$.value;
+    const isAccountingClassesEnabled = getIsAccountingClassesEnabled(state);
+    const cached = getRecommendationsForEntity(state, entityIdOrName, 'vendor');
+    // Cache hit: apply straight away, no request and no wait.
+    if (cached.fetchState === 'Completed') {
+        return of(setRecommendationsForCreateTransactionLines(transactionType, lineIds, cached.recommendations ?? [], isAccountingClassesEnabled));
+    }
+    const waitThenApply = actions$.pipe(filter(indicateReadyToInitializeRecommendation.match), filter((ready) => ready.payload.entityType === 'vendor' &&
+        ready.payload.entityIdOrName === entityIdOrName), take(1), // don't listen forever! IMPORTANT!
+    mergeMap(() => from([
+        setRecommendationsForCreateTransactionLines(transactionType, lineIds, getRecommendationsForEntity(state$.value, entityIdOrName, 'vendor').recommendations ?? [], getIsAccountingClassesEnabled(state$.value)),
+    ])));
+    // A fetch already in flight needs no second request, only the wait.
+    if (cached.fetchState === 'In-Progress') {
+        return waitThenApply;
+    }
+    return concat(of((isUnsyncedVendor(entity)
+        ? fetchRecommendationByEntityName(entityIdOrName, 'vendor')
+        : fetchRecommendationByEntityId(entityIdOrName, 'vendor'))), waitThenApply);
+}));

package/lib/esm/view/transactionDetail/createTransaction/epics/initializeCreateTransactionLocalDataEpic.js

@@ -0,0 +1,14 @@
+import { filter, map } from 'rxjs/operators';
+import { initializeCreateTransactionLocalData, updateCreateTransactionLocalData, } from '../../transactionDetailReducer';
+import { getSeededCreateTransactionLocalData } from '../createTransactionLocalDataHelper';
+/**
+ * Seeds the working copy when the Create form opens: today's date, the default line set for the
+ * type, and a check's mandatory payment_type.
+ *
+ * Mirrors the `else` branch of initializeScheduleDetailLocalDataEpic -- a create has no
+ * existing entity to read from, so there is nothing to merge, only defaults to apply.
+ */
+export const initializeCreateTransactionLocalDataEpic = (actions$) => actions$.pipe(filter(initializeCreateTransactionLocalData.match), map((action) => {
+    const { transactionType } = action.payload;
+    return updateCreateTransactionLocalData(transactionType, getSeededCreateTransactionLocalData(transactionType));
+}));