@zeniai/client-epic-state 5.2.91 → 5.2.93-betaNB1

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

@@ -0,0 +1,164 @@
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { getAccountBaseForTransferAccounts } from '../../../entity/account/accountSelector';
+import { getClassById } from '../../../entity/class/classSelector';
+import { toProjectBasePayload, } from '../../../entity/project/projectPayload';
+import { getProjectById } from '../../../entity/project/projectSelector';
+import { getVendorByQboId, 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 (line.projectId != null) {
+        lineDetail.project = toProjectBasePayload(getProjectById(state.projectState, line.projectId) ?? {
+            projectId: line.projectId,
+            projectName: '',
+        });
+    }
+    if (transactionType === 'journal_entry') {
+        lineDetail.posting_type = line.postingType;
+        const vendorQboId = toQboLineVendorId(state, line.vendorQboId);
+        if (vendorQboId != null) {
+            lineDetail.vendor = { qbo_id: 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,
+    };
+};
+/**
+ * Thrown when a picked id has no QBO id to send. Sending the Zeni id instead would reach QBO as
+ * an unknown reference and come back as an opaque error, so the create is stopped here and the
+ * epic shows this message instead.
+ */
+export class UnresolvedCreateTransactionIdError extends Error {
+}
+/**
+ * Resolves a transfer account (the Zeni account id from the transfer pools) to its QBO id. The
+ * header and line account dropdowns already hold the QBO id, so they are sent as-is.
+ */
+const toQboTransferAccountId = (state, accountId) => {
+    if (accountId == null) {
+        return undefined;
+    }
+    const qboId = getAccountBaseForTransferAccounts(state.accountState, accountId)?.qboId;
+    if (qboId == null || qboId === '') {
+        throw new UnresolvedCreateTransactionIdError('The selected transfer account could not be found in QuickBooks.');
+    }
+    return qboId;
+};
+/** 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;
+    }
+    const qboId = getClassById(state.classState, {
+        classId,
+        reportId: 'class_list',
+    })?.qboId;
+    if (qboId == null || qboId === '') {
+        throw new UnresolvedCreateTransactionIdError('The selected class could not be found in QuickBooks.');
+    }
+    return qboId;
+};
+/** A vendor not yet synced to QBO carries `qboId === name`, which QBO would reject. */
+const toSyncedVendorQboId = (vendor) => {
+    if (vendor == null || vendor.qboId === '' || vendor.qboId === vendor.name) {
+        throw new UnresolvedCreateTransactionIdError('The selected vendor is not synced to QuickBooks yet.');
+    }
+    return vendor.qboId;
+};
+/** Resolves a Zeni vendor id to its QBO id -- `vendor_id` on the wire is a QBO id. */
+const toQboVendorId = (state, vendorId) => vendorId == null
+    ? undefined
+    : toSyncedVendorQboId(getVendorByVendorId(state.vendorState, vendorId));
+/** A journal entry line holds the QBO id already, so it is only checked against the store. */
+const toQboLineVendorId = (state, vendorQboId) => vendorQboId == null
+    ? undefined
+    : toSyncedVendorQboId(getVendorByQboId(state.vendorState, vendorQboId));
+/**
+ * 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.
+ *
+ * Throws UnresolvedCreateTransactionIdError when a picked vendor (header or journal entry line),
+ * class or transfer account has no QBO id.
+ */
+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: toQboTransferAccountId(state, localData.fromAccountId),
+            to_account_id: toQboTransferAccountId(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: 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. The seed sets
+        // payment_type to credit_card, since qbo_purchase.py raises on is_credit without a card type.
+        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,47 @@
+import { createSelector } from '@reduxjs/toolkit';
+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,
+    };
+};
+/**
+ * Memoized: app-ui reads this straight from useSelector, and the vendor list and hierarchies are
+ * rebuilt on every call, so an unmemoized version re-renders the page on every store action.
+ */
+export const getCreateTransactionView = createSelector([
+    (state) => state.transactionDetailState.createTransactionsState,
+    (state) => state.vendorState.vendorByID,
+    (state) => state.accountListState,
+    (state) => state.classListState,
+    (state) => getResolvedTransferAccounts(state).transferAccountsList,
+    (_state, transactionType) => transactionType,
+], (createTransactionsState, vendorByID, accountListState, classListState, transferAccountsList, transactionType) => ({
+    transactionType,
+    localData: createTransactionsState.newTransactionState[transactionType],
+    createStatus: createTransactionsState.createStatus,
+    createdTransactionId: createTransactionsState.createdTransactionId,
+    vendorList: Object.values(vendorByID),
+    accountListNestedAccountHierarchy: getNestedAccountListHierarchy(accountListState, 'accountList'),
+    classListNestedAccountHierarchy: getNestedClassListHierarchy(classListState),
+    transferAccountsList: transactionType === 'transfer' ? 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/createTransactionAttachmentUploadFailureEpic.js

@@ -0,0 +1,19 @@
+import { filter, map } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createTransactionAttachmentUploadFailure } from '../../transactionDetailReducer';
+/**
+ * Attachments upload from the page after the create succeeds, so a failure is reported back here
+ * rather than by createTransactionEpic.
+ */
+export const createTransactionAttachmentUploadFailureEpic = (actions$) => actions$.pipe(filter(createTransactionAttachmentUploadFailure.match), filter((action) => action.payload.failedAttachmentFileNames.length > 0), map((action) => openSnackbar({
+    messageSection: 'missing_receipts_attachment',
+    messageText: 'failed',
+    type: 'error',
+    showStatusIcon: true,
+    variables: [
+        {
+            variableName: '__message__',
+            variableValue: ` - ${action.payload.failedAttachmentFileNames.join(', ')},`,
+        },
+    ],
+})));

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

@@ -0,0 +1,81 @@
+import { defer, from } from 'rxjs';
+import { catchError, exhaustMap, 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, } from '../../transactionDetailReducer';
+import { getTransactionDetailKey } from '../../transactionDetailState';
+import { UnresolvedCreateTransactionIdError, prepareCreateTransactionPayload, } from '../createTransactionPayload';
+export const createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createTransaction.match), 
+// exhaustMap, not mergeMap: a second submit while one is in flight is dropped here rather
+// than relying only on the disabled Save button, so it cannot create a duplicate in QBO.
+exhaustMap((action) => {
+    const { transactionType } = action.payload;
+    const state = state$.value;
+    const localData = state.transactionDetailState.createTransactionsState
+        .newTransactionState[transactionType];
+    // Deferred so a payload that cannot be built (an id with no QBO id) lands in catchError
+    // below as a failure, instead of throwing out of the epic.
+    return defer(() => zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, prepareCreateTransactionPayload(state, localData))).pipe(mergeMap((response) => {
+        const created = isSuccessResponse(response)
+            ? response.data?.transactions[0]
+            : undefined;
+        if (created == null) {
+            const status = isSuccessResponse(response)
+                ? createZeniAPIStatus('Unexpected Error', 'Transaction was created but returned no details.')
+                : response.status;
+            return from([
+                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.
+                    variables: [
+                        { variableName: '_api-error_', variableValue: status.message },
+                    ],
+                }),
+            ]);
+        }
+        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),
+            // No reset here: it would clear createdTransactionId in the same tick, before the
+            // screen renders it to upload pending attachments and navigate. The screen resets
+            // the working copy on unmount instead.
+            // Before the local-data init: it seeds the detail entry that init writes into.
+            createTransactionSuccessOrFailure('Completed', newTransactionId),
+            initializeTransactionDetailLocalData({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            openSnackbar({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), catchError((error) => {
+        const message = error instanceof UnresolvedCreateTransactionIdError
+            ? error.message
+            : JSON.stringify(error);
+        return from([
+            createTransactionSuccessOrFailure('Error', undefined, createZeniAPIStatus('Unexpected Error', `Create Transaction REST API call errored out ${message}`)),
+            openSnackbar({
+                messageSection: 'create_transaction',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    { variableName: '_api-error_', variableValue: message },
+                ],
+            }),
+        ]);
+    }));
+}));

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

@@ -0,0 +1,53 @@
+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,10 @@
+import { filter, map } from 'rxjs/operators';
+import { initializeCreateTransactionLocalData, resetCreateTransactionLocalData, } from '../../transactionDetailReducer';
+/**
+ * Seeds the working copy when the Create form opens: today's date, the default line set for the
+ * type, and the payment_type the backend insists on.
+ *
+ * The seed replaces the whole working copy rather than merging into it, so a second initialize
+ * for the same type can't leave the previous draft's vendor, memo or account behind.
+ */
+export const initializeCreateTransactionLocalDataEpic = (actions$) => actions$.pipe(filter(initializeCreateTransactionLocalData.match), map((action) => resetCreateTransactionLocalData(action.payload.transactionType)));

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

@@ -2,6 +2,7 @@ import { createSlice } from '@reduxjs/toolkit';
 import recordGet from 'lodash/get';
 import { toEntityType, } from '../../entity/genericEntity/entity';
 import { clearAll } from '../../rootActions';
+import { applyRecommendationsToCreateTransactionLine, clearRecommendationsFromCreateTransactionLine, getInitialCreateTransactionLocalDataByType, getSeededCreateTransactionLocalData, mergeCreateTransactionLocalData, nextCreateTransactionLineId, updateCreateTransactionLine, } from './createTransaction/createTransactionLocalDataHelper';
 import { removeEntityRecommendationForLineIdInLocalData, setEntityRecommendationForLineIdInLocalData, toSetAllLineItemsLocalDataIsUpdateAllChecked, toSetAllLineItemsToCategoryClass, toSetAllLineItemsToVendor, toUpdateLineItemsOriginalCategoryClass, toUpdateLineItemsToOriginalVendor, } from './transactionDetailLocalDataHelper';
 import { getTransactionDetailKey, initialSupportedTransactionDetail, } from './transactionDetailState';
 export const initialState = {
@@ -10,6 +11,10 @@ export const initialState = {
         fetchState: 'Not-Started',
         attachmentDataByID: {},
     },
+    createTransactionsState: {
+        createStatus: { fetchState: 'Not-Started' },
+        newTransactionState: getInitialCreateTransactionLocalDataByType(),
+    },
 };
 const transactionDetail = createSlice({
     name: 'transactionDetail',
@@ -829,6 +834,196 @@ const transactionDetail = createSlice({
                 };
             },
         },
+        // ---------------------------------------------------------------------------------
+        // Create Transaction
+        //
+        // These live on the transactionDetail slice rather than in createTransaction/ because a
+        // createSlice owns exactly one state object, and createTransactionsState is nested inside
+        // TransactionDetailState. The derivation itself stays in the folder -- each body below
+        // delegates to createTransactionLocalDataHelper.ts.
+        //
+        // They need no clearAll case of their own: the slice already resets to initialState on
+        // tenant switch, and createTransactionsState is part of it.
+        // ---------------------------------------------------------------------------------
+        /** Trigger only -- initializeCreateTransactionLocalDataEpic does the seeding. */
+        initializeCreateTransactionLocalData: {
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // no-op
+            },
+            prepare(transactionType) {
+                return { payload: { transactionType } };
+            },
+        },
+        updateCreateTransactionLocalData: {
+            reducer(draft, action) {
+                const { transactionType, localData } = action.payload;
+                const current = draft.createTransactionsState.newTransactionState[transactionType];
+                draft.createTransactionsState.newTransactionState[transactionType] =
+                    mergeCreateTransactionLocalData(current, localData);
+            },
+            prepare(transactionType, localData) {
+                return { payload: { transactionType, localData } };
+            },
+        },
+        updateCreateTransactionLineLocalData: {
+            reducer(draft, action) {
+                const { transactionType, lineId, lineUpdates } = action.payload;
+                const current = draft.createTransactionsState.newTransactionState[transactionType];
+                current.lines = updateCreateTransactionLine(current.lines, lineId, lineUpdates);
+            },
+            prepare(transactionType, lineId, lineUpdates) {
+                return { payload: { transactionType, lineId, lineUpdates } };
+            },
+        },
+        /**
+         * `line` is supplied by the caller rather than built here, so a row added after a vendor is
+         * already chosen can arrive pre-populated from the cached recommendations instead of blank.
+         */
+        addCreateTransactionLine: {
+            reducer(draft, action) {
+                const { transactionType, line } = action.payload;
+                draft.createTransactionsState.newTransactionState[transactionType].lines.push({
+                    ...line,
+                    id: nextCreateTransactionLineId(),
+                });
+            },
+            prepare(transactionType, line) {
+                return { payload: { transactionType, line } };
+            },
+        },
+        removeCreateTransactionLine: {
+            reducer(draft, action) {
+                const { transactionType, lineId } = action.payload;
+                const current = draft.createTransactionsState.newTransactionState[transactionType];
+                current.lines = current.lines.filter((line) => line.id !== lineId);
+            },
+            prepare(transactionType, lineId) {
+                return { payload: { transactionType, lineId } };
+            },
+        },
+        /**
+         * Restores the blank working copy AND re-seeds it, so reopening Create starts from a fresh
+         * form rather than the previous transaction's values.
+         */
+        resetCreateTransactionLocalData: {
+            reducer(draft, action) {
+                const { transactionType } = action.payload;
+                draft.createTransactionsState.newTransactionState[transactionType] =
+                    getSeededCreateTransactionLocalData(transactionType);
+                draft.createTransactionsState.createStatus = {
+                    fetchState: 'Not-Started',
+                };
+                draft.createTransactionsState.createdTransactionId = undefined;
+            },
+            prepare(transactionType) {
+                return { payload: { transactionType } };
+            },
+        },
+        /** Submit trigger -- createTransactionEpic builds the payload from localData. */
+        createTransaction: {
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.createTransactionsState.createStatus = {
+                    fetchState: 'In-Progress',
+                };
+                draft.createTransactionsState.createdTransactionId = undefined;
+            },
+            prepare(transactionType) {
+                return { payload: { transactionType } };
+            },
+        },
+        /**
+         * Trigger only -- fetchVendorRecommendationsForCreateTransactionEpic does the work.
+         * A null entity means the vendor was cleared.
+         */
+        fetchVendorRecommendationsForCreateTransaction: {
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // no-op
+            },
+            prepare(transactionType, lineIds, entity) {
+                return { payload: { transactionType, lineIds, entity } };
+            },
+        },
+        /** Trigger only -- createTransactionAttachmentUploadFailureEpic raises the snackbar. */
+        createTransactionAttachmentUploadFailure: {
+            reducer(
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                // no-op
+            },
+            prepare(failedAttachmentFileNames) {
+                return { payload: { failedAttachmentFileNames } };
+            },
+        },
+        /**
+         * Writes a vendor's recommendations into the named lines. `lineIds` is explicit rather than
+         * "all lines" because a journal entry recommends per line, from that line's own entity.
+         */
+        setRecommendationsForCreateTransactionLines: {
+            reducer(draft, action) {
+                const { transactionType, lineIds, recommendations, isAccountingClassesEnabled, } = action.payload;
+                const current = draft.createTransactionsState.newTransactionState[transactionType];
+                // Clear first: on vendor A -> B, A's prefill is no longer empty, so B's would never
+                // replace it. Fields the user picked carry no prefill flag and survive the clear.
+                current.lines = current.lines.map((line) => lineIds.includes(line.id)
+                    ? applyRecommendationsToCreateTransactionLine(clearRecommendationsFromCreateTransactionLine(line), recommendations, isAccountingClassesEnabled)
+                    : line);
+            },
+            prepare(transactionType, lineIds, recommendations, isAccountingClassesEnabled) {
+                return {
+                    payload: {
+                        transactionType,
+                        lineIds,
+                        recommendations,
+                        isAccountingClassesEnabled,
+                    },
+                };
+            },
+        },
+        /** Vendor cleared: drop the dropdown group and undo only what the prefill wrote. */
+        clearRecommendationsForCreateTransactionLines: {
+            reducer(draft, action) {
+                const { transactionType, lineIds } = action.payload;
+                const current = draft.createTransactionsState.newTransactionState[transactionType];
+                current.lines = current.lines.map((line) => lineIds.includes(line.id)
+                    ? clearRecommendationsFromCreateTransactionLine(line)
+                    : line);
+            },
+            prepare(transactionType, lineIds) {
+                return { payload: { transactionType, lineIds } };
+            },
+        },
+        createTransactionSuccessOrFailure: {
+            reducer(draft, action) {
+                const { fetchState, error, createdTransactionId } = action.payload;
+                draft.createTransactionsState.createStatus = { fetchState, error };
+                if (createdTransactionId != null) {
+                    draft.createTransactionsState.createdTransactionId =
+                        createdTransactionId;
+                    // The API will not return a QBO-only row until delta sync, so the optimistic insert
+                    // is marked fetched: detail local data can be saved and a fetch is a cache hit.
+                    draft.transactionDetailById[getTransactionDetailKey(createdTransactionId)] = {
+                        ...initialSupportedTransactionDetail,
+                        fetchState: 'Completed',
+                        transactionId: createdTransactionId,
+                    };
+                }
+            },
+            prepare(fetchState, createdTransactionId, error) {
+                return { payload: { fetchState, createdTransactionId, error } };
+            },
+        },
     },
     extraReducers: (builder) => {
         builder.addCase(clearAll, (draft) => {
@@ -836,7 +1031,7 @@ const transactionDetail = createSlice({
         });
     },
 });
-export const { downloadAccountingProviderAttachment, downloadAccountingProviderAttachmentSuccess, downloadAccountingProviderAttachmentFailure, fetchTransactionDetail, updateTransactionDetailFetchState, removeTransactionDetail, uploadMissingAttachmentSuccess, updateTransactionDetail, updateTransactionDetailSaveStatus, clearTransactionDetailSaveStatus, markTransactionAsNotMiscategorized, deleteTransactionAttachment, deleteTransactionAttachmentFailure, deleteTransactionAttachmentSuccess, updateStatusForTransactionNotMiscategorizedUpdate, updateStatusConsolidatedSaveTransactionDetail, updateTransactionStateIfUpdateActionNotAllowed, saveTransactionDetail, initializeTransactionDetailLocalData, saveTransactionDetailLocalData, clearTransactionDetailLocalData, resetLineItemsCategoryClassInLocalData, setAllLineItemsToCategoryClassInLocalData, setAllLineItemsLocalDataIsUpdateAllChecked, setEntityRecommendationForLineIdsForTransactionDetail, markCategoryClassRecommendationsInProgressForTransactionDetail, markCategoryClassRecommendationsCompletedForTransactionDetail, markCategoryClassRecommendationsFailureForTransactionDetail, removeEntityRecommendationForLineIdForTransactionDetail, updateSelectedVendor, updateSelectedCustomer, resetVendor, resetSelectedCustomer, updateLocalDataWithTransactionsUpdateWithVendorCheckbox, updateVendorToAllLineItems, resetAllLineItemsToVendor, updateLatestSelectedEntity, updateVendorBulkRecommendationsFetchStatus, setIsVendorUpdateAllChecked, addSplitLine, deleteSplitLine, toggleSplitEditMode, } = transactionDetail.actions;
+export const { downloadAccountingProviderAttachment, downloadAccountingProviderAttachmentSuccess, downloadAccountingProviderAttachmentFailure, fetchTransactionDetail, updateTransactionDetailFetchState, removeTransactionDetail, uploadMissingAttachmentSuccess, updateTransactionDetail, updateTransactionDetailSaveStatus, clearTransactionDetailSaveStatus, markTransactionAsNotMiscategorized, deleteTransactionAttachment, deleteTransactionAttachmentFailure, deleteTransactionAttachmentSuccess, updateStatusForTransactionNotMiscategorizedUpdate, updateStatusConsolidatedSaveTransactionDetail, updateTransactionStateIfUpdateActionNotAllowed, saveTransactionDetail, initializeTransactionDetailLocalData, saveTransactionDetailLocalData, clearTransactionDetailLocalData, resetLineItemsCategoryClassInLocalData, setAllLineItemsToCategoryClassInLocalData, setAllLineItemsLocalDataIsUpdateAllChecked, setEntityRecommendationForLineIdsForTransactionDetail, markCategoryClassRecommendationsInProgressForTransactionDetail, markCategoryClassRecommendationsCompletedForTransactionDetail, markCategoryClassRecommendationsFailureForTransactionDetail, removeEntityRecommendationForLineIdForTransactionDetail, updateSelectedVendor, updateSelectedCustomer, resetVendor, resetSelectedCustomer, updateLocalDataWithTransactionsUpdateWithVendorCheckbox, updateVendorToAllLineItems, resetAllLineItemsToVendor, updateLatestSelectedEntity, updateVendorBulkRecommendationsFetchStatus, setIsVendorUpdateAllChecked, addSplitLine, deleteSplitLine, toggleSplitEditMode, initializeCreateTransactionLocalData, updateCreateTransactionLocalData, updateCreateTransactionLineLocalData, addCreateTransactionLine, removeCreateTransactionLine, resetCreateTransactionLocalData, createTransaction, createTransactionSuccessOrFailure, setRecommendationsForCreateTransactionLines, clearRecommendationsForCreateTransactionLines, fetchVendorRecommendationsForCreateTransaction, createTransactionAttachmentUploadFailure, } = transactionDetail.actions;
 export default transactionDetail.reducer;
 function getUpdatedEntityLocalData(detail, updates, entity, resetRecommendations, type) {
     const key = type === 'customer' ? 'customerUpdates' : 'vendorUpdates';