@zeniai/client-epic-state 5.2.62-beta1MM → 5.2.62-beta2KB

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

@@ -1,11 +1,11 @@
 import orderBy from 'lodash/orderBy';
-import { createSelector } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { getActualMatchingMatchById } from '../../../entity/actualMatching/actualMatchingSelector';
 import { generateJEOneTimeAccrualKey } from '../../../entity/jeSchedules/jeScheduleHelper';
 import { getJEOneTimeAccrualByKey, } from '../../../entity/jeSchedules/jeSchedulesSelector';
 import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
 import { date } from '../../../zeniDayJS';
+import { actualMatchingTransactionLineKey, } from '../types/actualMatchingViewState';
 export function getSelectedMonthYearForCurrentTenant(state) {
     const tenantId = getCurrentTenant(state)?.tenantId;
     if (tenantId == null) {
@@ -34,6 +34,27 @@ function toMatchModalAccrual(member) {
         jeOneTimeAccrualKey: generateJEOneTimeAccrualKey(member.accrualId),
     };
 }
+function uniqueMatchModalAccruals(pinned, searched) {
+    const byId = new Map();
+    pinned.forEach((row) => byId.set(row.accrualId, row));
+    searched.forEach((row) => {
+        if (!byId.has(row.accrualId)) {
+            byId.set(row.accrualId, row);
+        }
+    });
+    return Array.from(byId.values());
+}
+function uniqueTransactionSearchResults(pinned, searched) {
+    const byKey = new Map();
+    pinned.forEach((row) => byKey.set(actualMatchingTransactionLineKey(row.transactionType, row.transactionIntegrationId, row.lineId), row));
+    searched.forEach((row) => {
+        const key = actualMatchingTransactionLineKey(row.transactionType, row.transactionIntegrationId, row.lineId);
+        if (!byKey.has(key)) {
+            byKey.set(key, row);
+        }
+    });
+    return Array.from(byKey.values());
+}
 export function parseActualMatchingMatchId(matchId) {
     const separator = matchId.indexOf(':');
     if (separator <= 0 || separator === matchId.length - 1) {
@@ -206,7 +227,6 @@ function emptyKpiSummary() {
         actualsReceived: { count: 0, expectedCount: 0, vendorsPending: 0 },
         autoReversed: { count: 0, percent: 0, clearedAmount: 0 },
         pendingReview: { count: 0, amount: 0, estimatedMinutesToClear: 0 },
-        reversed: { count: 0 },
         variance: { percent: 0, averagePercentPerMatch: 0, netAmount: 0 },
     };
 }
@@ -262,7 +282,6 @@ export function buildActualMatchingKpiSummary(rows, displayCurrencyCode) {
     }
     const autoReversed = kpiRows.filter((row) => row.kind === 'auto_reversed');
     const pendingReview = kpiRows.filter((row) => row.kind === 'pending_review');
-    const reversed = kpiRows.filter((row) => isReversedMatchKind(row.kind));
     const receivedCount = kpiRows.length;
     const rowsWithActual = kpiRows.filter((row) => row.actualAmount?.amount != null);
     const accruedTotal = rowsWithActual.reduce((sum, row) => sum + (row.accruedAmount?.amount ?? row.estimatedAmount.amount), 0);
@@ -288,9 +307,6 @@ export function buildActualMatchingKpiSummary(rows, displayCurrencyCode) {
             amount: sumRowAmounts(pendingReview, displayCurrencyCode),
             estimatedMinutesToClear: pendingReview.length * ESTIMATED_MINUTES_PER_PENDING_MATCH,
         },
-        reversed: {
-            count: reversed.length,
-        },
         variance: {
             percent: accruedTotal === 0
                 ? 0
@@ -303,56 +319,23 @@ export function buildActualMatchingKpiSummary(rows, displayCurrencyCode) {
         },
     };
 }
-function toActualMatchingMatchView(match) {
+export function getExpenseAutomationActualMatchingMatchView(state, matchId) {
+    const view = state.expenseAutomationActualMatchingViewState;
     return {
-        ...match,
-        members: match.members.map(toMatchModalAccrual),
-        leftovers: match.leftovers == null
-            ? undefined
-            : match.leftovers.map(toMatchModalAccrual),
+        match: getActualMatchingMatchById(state.actualMatchingState, matchId),
+        detailFetchState: view.detailFetchStateByMatchId[matchId] ?? NOT_STARTED,
+        refreshStatus: view.detailRefreshStatusByMatchId[matchId] ?? NOT_STARTED,
+        undoReversalStatus: view.undoReversalStatusByMatchId[matchId] ?? NOT_STARTED,
+        lastMatchResults: view.lastMatchResultsByMatchId?.[matchId],
+        lastUndoResults: view.lastUndoResultsByMatchId?.[matchId],
     };
 }
-const EMPTY_ACTUAL_MATCHING_ROWS = [];
-const matchViewSelectorById = new Map();
-export function getExpenseAutomationActualMatchingMatchView(state, matchId) {
-    let selector = matchViewSelectorById.get(matchId);
-    if (selector == null) {
-        selector = createSelector([
-            (root) => root.expenseAutomationActualMatchingViewState,
-            (root) => getActualMatchingMatchById(root.actualMatchingState, matchId),
-        ], (view, match) => ({
-            detailFetchState: view.detailFetchStateByMatchId[matchId] ?? NOT_STARTED,
-            ignoreStatus: view.ignoreStatusByMatchId[matchId] ?? NOT_STARTED,
-            lastMatchResults: view.lastMatchResultsByMatchId?.[matchId],
-            lastUndoResults: view.lastUndoResultsByMatchId?.[matchId],
-            match: match == null ? undefined : toActualMatchingMatchView(match),
-            refreshStatus: view.detailRefreshStatusByMatchId[matchId] ?? NOT_STARTED,
-            undoReversalStatus: view.undoReversalStatusByMatchId[matchId] ?? NOT_STARTED,
-        }));
-        matchViewSelectorById.set(matchId, selector);
-    }
-    return selector(state);
-}
 export function getCloseMatchAfterUndo(state) {
-    return state.expenseAutomationActualMatchingViewState
-        .closeMatchAfterUndoMatchIds[0];
-}
-export function getCloseMatchAfterUndoMatchId(state) {
-    return getCloseMatchAfterUndo(state);
-}
-export function getCloseMatchAfterIgnoreMatchId(state) {
-    return state.expenseAutomationActualMatchingViewState
-        .closeMatchAfterIgnoreMatchIds[0];
-}
-export function getActualMatchingMatchModalConfirmStatus(state, matchId) {
-    if (matchId != null && matchId !== '') {
-        return (state.expenseAutomationActualMatchingViewState.confirmStatusByMatchId[matchId] ?? NOT_STARTED);
-    }
-    return state.expenseAutomationActualMatchingViewState.matchModal.confirmStatus;
+    return state.expenseAutomationActualMatchingViewState.closeMatchAfterUndo;
 }
 export function getExpenseAutomationActualMatchingView(state) {
     const { expenseAutomationActualMatchingViewState } = state;
-    const { matchIdsByPeriod, fetchState, error, refreshStatus, uiState, matchModal, ignoreStatusByMatchId, undoReversalStatusByMatchId, } = expenseAutomationActualMatchingViewState;
+    const { matchIdsByPeriod, fetchState, error, refreshStatus, uiState, matchModal, } = expenseAutomationActualMatchingViewState;
     const selectedPeriod = getSelectedMonthYearForCurrentTenant(state);
     const monthYearPeriodId = selectedPeriod != null ? toMonthYearPeriodId(selectedPeriod) : undefined;
     const matchIds = monthYearPeriodId != null ? matchIdsByPeriod[monthYearPeriodId] : undefined;
@@ -362,18 +345,38 @@ export function getExpenseAutomationActualMatchingView(state) {
         .filter((match) => match.members.length > 0)
         .map(toActualMatchingRow);
     const rows = allRows.filter((row) => matchesSearch(row, uiState.searchString));
-    const includePendingReview = uiState.statusFilter !== 'reversed';
-    const includeReversed = uiState.statusFilter !== 'pending_review';
-    const reversed = includeReversed
-        ? sortActualMatchingRows(rows.filter((row) => isReversedMatchKind(row.kind)), uiState)
-        : EMPTY_ACTUAL_MATCHING_ROWS;
-    const pendingReview = includePendingReview
-        ? sortActualMatchingRows(rows.filter((row) => row.kind === 'pending_review'), uiState)
-        : EMPTY_ACTUAL_MATCHING_ROWS;
+    const reversed = sortActualMatchingRows(rows.filter((row) => isReversedMatchKind(row.kind)), uiState);
+    const pendingReview = sortActualMatchingRows(rows.filter((row) => row.kind === 'pending_review'), uiState);
     const kpiSummary = buildActualMatchingKpiSummary(allRows, getTenantDisplayCurrency(state)?.currencyCode);
     const searchedAccruals = matchModal.accrualSearch.results
         .map((key) => getJEOneTimeAccrualByKey(key, state.jeSchedulesState))
         .filter((accrual) => accrual != null);
+    const openedMatch = matchModal.openedFromMatchId != null
+        ? getActualMatchingMatchById(state.actualMatchingState, matchModal.openedFromMatchId)
+        : undefined;
+    const pinnedAccruals = [
+        ...(openedMatch?.members ?? []),
+        ...(openedMatch?.leftovers ?? []),
+    ].map(toMatchModalAccrual);
+    const firstMember = openedMatch?.members[0];
+    const cleared = firstMember?.cleared;
+    const suggestion = firstMember?.matchSuggestion;
+    const stamp = cleared ?? suggestion;
+    const consumedLineIds = cleared?.consumedLineIds;
+    const prefill = openedMatch == null
+        ? undefined
+        : {
+            selectedAccrualIds: [
+                ...openedMatch.members.map((member) => member.accrualId),
+                ...(openedMatch.leftovers ?? []).map((leftover) => leftover.accrualId),
+            ],
+            actualAmount: openedMatch.actualAmount.amount,
+            matchedTransactionId: stamp?.matchedTransactionId,
+            matchedLineId: cleared == null ? suggestion?.matchedLineId : undefined,
+            ...(consumedLineIds != null && consumedLineIds.length > 0
+                ? { consumedLineIds }
+                : {}),
+        };
     // `fetchState` is a flat slice field that survives a period switch. Until this
     // month's ids land, leftover Completed/Error is the previous month. Report
     // Not-Started so chrome matches Review's "cache slot missing" skeleton, not
@@ -391,16 +394,16 @@ export function getExpenseAutomationActualMatchingView(state) {
         kpiSummary,
         uiState,
         refreshStatus,
-        ignoreStatusByMatchId,
-        undoReversalStatusByMatchId,
         hasLoadedForSelectedPeriod: matchIds != null,
         matchModal: {
             isOpen: matchModal.isOpen,
+            openedFromMatchId: matchModal.openedFromMatchId,
+            prefill,
             confirmStatus: matchModal.confirmStatus,
             lastBatchResults: matchModal.lastBatchResults,
             transactionSearch: {
                 query: matchModal.transactionSearch.query,
-                results: matchModal.transactionSearch.results,
+                results: uniqueTransactionSearchResults(matchModal.pinnedTransactionResults, matchModal.transactionSearch.results),
                 fetchState: {
                     fetchState: matchModal.transactionSearch.fetchState,
                     error: matchModal.transactionSearch.error,
@@ -410,7 +413,7 @@ export function getExpenseAutomationActualMatchingView(state) {
             },
             accrualSearch: {
                 query: matchModal.accrualSearch.query,
-                results: searchedAccruals,
+                results: uniqueMatchModalAccruals(pinnedAccruals, searchedAccruals),
                 fetchState: {
                     fetchState: matchModal.accrualSearch.fetchState,
                     error: matchModal.accrualSearch.error,

package/lib/esm/view/expenseAutomationView/types/actualMatchingViewState.js

@@ -13,12 +13,6 @@ const ACTUAL_MATCHING_SORT_KEYS = [
     'variance',
 ];
 export const toActualMatchingSortKey = (v) => stringToUnion(v, ACTUAL_MATCHING_SORT_KEYS);
-const ACTUAL_MATCHING_STATUS_FILTERS = [
-    'all',
-    'pending_review',
-    'reversed',
-];
-export const toActualMatchingStatusFilter = (v) => stringToUnion(v, ACTUAL_MATCHING_STATUS_FILTERS);
 export const MATCH_TRANSACTION_SEARCH_PAGE_SIZE = 50;
 export const MATCH_ACCRUAL_SEARCH_LIMIT = 50;
 export const MATCH_SEARCH_DEBOUNCE_MS = 300;
@@ -39,15 +33,6 @@ const UNDO_REVERSAL_RESULT_STATUSES = [
     'error',
 ];
 export const toUndoReversalResultStatus = (v) => stringToUnion(v, UNDO_REVERSAL_RESULT_STATUSES);
-const ACTUAL_MATCHING_IGNORE_REASONS = [
-    'wrong_bill',
-    'wrong_period',
-    'amount_off',
-    'already_handled',
-    'other_ignore',
-];
-export const toActualMatchingIgnoreReasonType = (v) => stringToUnion(v, ACTUAL_MATCHING_IGNORE_REASONS);
-export const ALL_ACTUAL_MATCHING_IGNORE_REASONS = ACTUAL_MATCHING_IGNORE_REASONS;
 export function actualMatchingTransactionLineKey(transactionType, transactionIntegrationId, lineId) {
     return `${transactionType}:${transactionIntegrationId}:${lineId}`;
 }

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,132 @@
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { getAccountBase } from '../../../entity/account/accountSelector';
+import { getClassById } from '../../../entity/class/classSelector';
+import { toProjectBasePayload, } from '../../../entity/project/projectPayload';
+import { getProjectById } from '../../../entity/project/projectSelector';
+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 (line.projectId != null) {
+        lineDetail.project = toProjectBasePayload(getProjectById(state.projectState, line.projectId) ?? {
+            projectId: line.projectId,
+            projectName: '',
+        });
+    }
+    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,60 @@
+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, } 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,
+            }),
+            // 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.
+            createTransactionSuccessOrFailure('Completed', newTransactionId),
+            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)}`)))));
+}));