@zeniai/client-epic-state 5.2.91 → 5.2.93

package/lib/view/transactionDetail/createTransaction/createTransactionSelector.d.ts

@@ -0,0 +1,44 @@
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { FetchState, FetchStateAndError } from '../../../commonStateTypes/common';
+import { Recommendation } from '../../../commonStateTypes/recommendationBase';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase } from '../../../entity/account/accountState';
+import { TransactionID } from '../../../entity/transaction/stateTypes/transactionID';
+import { Vendor } from '../../../entity/vendor/vendorState';
+import { RootState } from '../../../rootStateTypes';
+import { CreatableTransactionType, CreateTransactionLocalData } from './createTransactionState';
+export interface CreateTransactionView extends SelectorView {
+    /**
+     * COA and class trees for the header account and the line dropdowns. The hierarchies rather
+     * than flat lists, because the create page builds its grouped "Recommended" / "All" options
+     * with the same helpers the detail page uses.
+     */
+    accountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    classListNestedAccountHierarchy: NestedClassHierarchyForReport[];
+    createStatus: FetchStateAndError;
+    localData: CreateTransactionLocalData;
+    transactionType: CreatableTransactionType;
+    /** Populated for transfer only; the COA would offer ineligible accounts. */
+    transferAccountsList: AccountBase[];
+    vendorList: Vendor[];
+    createdTransactionId?: TransactionID;
+}
+export declare const getCreateTransactionLocalData: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionLocalData;
+export declare const getCreateTransactionStatus: (state: RootState) => FetchStateAndError;
+/**
+ * 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 declare const getCreateTransactionVendorRecommendations: (state: RootState, vendorQboId?: string) => {
+    fetchState: FetchState;
+    recommendations?: Recommendation[];
+};
+/**
+ * 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 declare const getCreateTransactionView: (state: RootState, transactionType: CreatableTransactionType) => CreateTransactionView;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCreateTransactionView = exports.getCreateTransactionVendorRecommendations = exports.getCreateTransactionStatus = exports.getCreateTransactionLocalData = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const classListSelector_1 = require("../../classList/classListSelector");
+const createTransferEntrySelector_1 = require("../../createTransferEntry/createTransferEntrySelector");
+const recommendationSelector_1 = require("../../recommendation/recommendationSelector");
+const getCreateTransactionLocalData = (state, transactionType) => state.transactionDetailState.createTransactionsState.newTransactionState[transactionType];
+exports.getCreateTransactionLocalData = getCreateTransactionLocalData;
+const getCreateTransactionStatus = (state) => state.transactionDetailState.createTransactionsState.createStatus;
+exports.getCreateTransactionStatus = getCreateTransactionStatus;
+/**
+ * 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.
+ */
+const getCreateTransactionVendorRecommendations = (state, vendorQboId) => {
+    if (vendorQboId == null || vendorQboId === '') {
+        return { fetchState: 'Not-Started' };
+    }
+    const view = (0, recommendationSelector_1.getRecommendationsForEntity)(state, vendorQboId, 'vendor');
+    return {
+        fetchState: view.fetchState,
+        recommendations: view.recommendations,
+    };
+};
+exports.getCreateTransactionVendorRecommendations = getCreateTransactionVendorRecommendations;
+/**
+ * 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.
+ */
+exports.getCreateTransactionView = (0, toolkit_1.createSelector)([
+    (state) => state.transactionDetailState.createTransactionsState,
+    (state) => state.vendorState.vendorByID,
+    (state) => state.accountListState,
+    (state) => state.classListState,
+    (state) => (0, createTransferEntrySelector_1.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: (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, 'accountList'),
+    classListNestedAccountHierarchy: (0, classListSelector_1.getNestedClassListHierarchy)(classListState),
+    transferAccountsList: transactionType === 'transfer' ? transferAccountsList : [],
+    fetchState: createTransactionsState.createStatus.fetchState,
+    error: createTransactionsState.createStatus.error,
+}));

package/lib/view/transactionDetail/createTransaction/createTransactionState.d.ts

@@ -0,0 +1,82 @@
+import { Amount } from '../../../commonStateTypes/amount';
+import { ID } from '../../../commonStateTypes/common';
+import { RecommendationWithCOT } from '../../../commonStateTypes/recommendationBase';
+import { PaymentType } from '../../../entity/transaction/stateTypes/paymentType';
+import { PrintStatus } from '../../../entity/transaction/stateTypes/printStatus';
+import { TransactionCategory, TransactionType } from '../../../entity/transaction/stateTypes/transactionType';
+import { ZeniDate } from '../../../zeniDayJS';
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+export declare const ALL_CREATABLE_TRANSACTION_TYPES: readonly ["expense", "check", "credit_card_credit", "transfer", "journal_entry"];
+export type CreatableTransactionType = (typeof ALL_CREATABLE_TRANSACTION_TYPES)[number];
+/**
+ * The wire shape the create endpoint expects for a check's remit-to address. Deliberately not
+ * the CES AddressPayload, which carries `street: string[]` plus address_id/create_time/
+ * update_time that the create endpoint does not accept.
+ */
+export interface RemitToAddress {
+    city?: string;
+    country?: string;
+    line1?: string;
+    postalCode?: string;
+    state?: string;
+}
+export interface CreateTransactionLineLocalData {
+    /** Client-side row key only -- never sent. */
+    id: string;
+    accountName?: string;
+    accountQboId?: ID;
+    amount?: Amount;
+    classId?: ID;
+    className?: string;
+    /**
+     * Tracked per field, not per line. A line can have a hand-picked account and a prefilled
+     * class at the same time, and clearing the vendor must undo only the latter.
+     */
+    isAccountPreFilled?: boolean;
+    isClassPreFilled?: boolean;
+    lineDescription?: string;
+    /** journal_entry only. */
+    postingType?: TransactionCategory;
+    projectId?: ID;
+    /**
+     * Backs the "Recommended" group in the category/class dropdowns. Carries the COT shape the
+     * line-table row already expects, with empty cot/reasoning -- chain-of-thought needs an
+     * existing transaction, which a create does not have.
+     */
+    recommendationsWithCOT?: RecommendationWithCOT[];
+    /** journal_entry only -- the per-line name. */
+    vendorQboId?: ID;
+}
+export interface CreateTransactionLocalData {
+    /** Empty for transfer, which has no lines at all. */
+    lines: CreateTransactionLineLocalData[];
+    transactionType: CreatableTransactionType;
+    /** journal_entry reference number. */
+    documentId?: string;
+    /** check / credit_card_credit reference number. */
+    documentNumber?: string;
+    /** transfer */
+    fromAccountId?: ID;
+    paymentType?: PaymentType;
+    /** check only. */
+    printStatus?: PrintStatus;
+    qboAccountId?: ID;
+    /** check only. */
+    remitToAddress?: RemitToAddress;
+    toAccountId?: ID;
+    /** transfer only -- every other type derives its total from the lines. */
+    totalAmount?: Amount;
+    transactionDate?: ZeniDate;
+    transactionMemo?: string;
+    vendorId?: ID;
+}
+export type CreateTransactionLocalDataByType = Record<CreatableTransactionType, CreateTransactionLocalData>;
+/**
+ * Type-level guarantee that CreatableTransactionType stays a subset of TransactionType. If a
+ * value is ever added here that the entity layer does not know about, this line fails to
+ * compile rather than failing at the payload boundary.
+ */
+export type CreatableTransactionTypeIsTransactionType = CreatableTransactionType extends TransactionType ? true : never;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_CREATABLE_TRANSACTION_TYPES = void 0;
+/**
+ * The transaction types the Create Transaction flow can originate. A narrow subset of
+ * TransactionType -- everything else is read-only and arrives via sync.
+ */
+exports.ALL_CREATABLE_TRANSACTION_TYPES = [
+    'expense',
+    'check',
+    'credit_card_credit',
+    'transfer',
+    'journal_entry',
+];

package/lib/view/transactionDetail/createTransaction/epics/createTransactionAttachmentUploadFailureEpic.d.ts

@@ -0,0 +1,10 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createTransactionAttachmentUploadFailure } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransactionAttachmentUploadFailure> | ReturnType<typeof openSnackbar>;
+/**
+ * Attachments upload from the page after the create succeeds, so a failure is reported back here
+ * rather than by createTransactionEpic.
+ */
+export declare const createTransactionAttachmentUploadFailureEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;

package/lib/view/transactionDetail/createTransaction/epics/createTransactionAttachmentUploadFailureEpic.js

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

package/lib/view/transactionDetail/createTransaction/epics/createTransactionEpic.d.ts

@@ -0,0 +1,9 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTransaction } from '../../../../entity/transaction/transactionReducer';
+import { RootState } from '../../../../rootStateTypes';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { createTransaction, createTransactionSuccessOrFailure, initializeTransactionDetailLocalData } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof createTransaction> | ReturnType<typeof createTransactionSuccessOrFailure> | ReturnType<typeof initializeTransactionDetailLocalData> | ReturnType<typeof updateTransaction> | ReturnType<typeof openSnackbar>;
+export declare const createTransactionEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransactionEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const transactionIDPayload_1 = require("../../../../entity/transaction/payloadTypes/transactionIDPayload");
+const transactionReducer_1 = require("../../../../entity/transaction/transactionReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const transactionDetailReducer_1 = require("../../transactionDetailReducer");
+const transactionDetailState_1 = require("../../transactionDetailState");
+const createTransactionPayload_1 = require("../createTransactionPayload");
+const createTransactionEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.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.
+(0, operators_1.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 (0, rxjs_1.defer)(() => zeniAPI.postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/transactions/manage`, (0, createTransactionPayload_1.prepareCreateTransactionPayload)(state, localData))).pipe((0, operators_1.mergeMap)((response) => {
+        const created = (0, responsePayload_1.isSuccessResponse)(response)
+            ? response.data?.transactions[0]
+            : undefined;
+        if (created == null) {
+            const status = (0, responsePayload_1.isSuccessResponse)(response)
+                ? (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Transaction was created but returned no details.')
+                : response.status;
+            return (0, rxjs_1.from)([
+                (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Error', undefined, status),
+                (0, snackbarReducer_1.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 = (0, transactionIDPayload_1.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 (0, rxjs_1.from)([
+            (0, transactionReducer_1.updateTransaction)((0, transactionDetailState_1.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.
+            (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Completed', newTransactionId),
+            (0, transactionDetailReducer_1.initializeTransactionDetailLocalData)({
+                transactionId: newTransactionId,
+                vendorId: created.vendor_id ?? undefined,
+            }),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'create_transaction',
+                messageText: 'success',
+                type: 'success',
+            }),
+        ]);
+    }), (0, operators_1.catchError)((error) => {
+        const message = error instanceof createTransactionPayload_1.UnresolvedCreateTransactionIdError
+            ? error.message
+            : JSON.stringify(error);
+        return (0, rxjs_1.from)([
+            (0, transactionDetailReducer_1.createTransactionSuccessOrFailure)('Error', undefined, (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', `Create Transaction REST API call errored out ${message}`)),
+            (0, snackbarReducer_1.openSnackbar)({
+                messageSection: 'create_transaction',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    { variableName: '_api-error_', variableValue: message },
+                ],
+            }),
+        ]);
+    }));
+}));
+exports.createTransactionEpic = createTransactionEpic;

package/lib/view/transactionDetail/createTransaction/epics/fetchVendorRecommendationsForCreateTransactionEpic.d.ts

@@ -0,0 +1,20 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../rootStateTypes';
+import { fetchRecommendationByEntityId, fetchRecommendationByEntityName, indicateReadyToInitializeRecommendation } from '../../../recommendation/recommendationReducer';
+import { clearRecommendationsForCreateTransactionLines, fetchVendorRecommendationsForCreateTransaction, setRecommendationsForCreateTransactionLines } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof fetchVendorRecommendationsForCreateTransaction> | ReturnType<typeof setRecommendationsForCreateTransactionLines> | ReturnType<typeof clearRecommendationsForCreateTransactionLines> | ReturnType<typeof fetchRecommendationByEntityId> | ReturnType<typeof fetchRecommendationByEntityName> | ReturnType<typeof indicateReadyToInitializeRecommendation>;
+/**
+ * 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 declare const fetchVendorRecommendationsForCreateTransactionEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>) => Observable<ActionType>;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchVendorRecommendationsForCreateTransactionEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const tenantSelector_1 = require("../../../../entity/tenant/tenantSelector");
+const recommendationReducer_1 = require("../../../recommendation/recommendationReducer");
+const recommendationSelector_1 = require("../../../recommendation/recommendationSelector");
+const transactionDetailReducer_1 = require("../../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.
+ */
+const fetchVendorRecommendationsForCreateTransactionEpic = (actions$, state$) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.fetchVendorRecommendationsForCreateTransaction.match), (0, operators_1.switchMap)((action) => {
+    const { transactionType, entity, lineIds } = action.payload;
+    if (entity == null) {
+        return (0, rxjs_1.of)((0, transactionDetailReducer_1.clearRecommendationsForCreateTransactionLines)(transactionType, lineIds));
+    }
+    const entityIdOrName = toEntityIdOrName(entity);
+    const state = state$.value;
+    const isAccountingClassesEnabled = (0, tenantSelector_1.getIsAccountingClassesEnabled)(state);
+    const cached = (0, recommendationSelector_1.getRecommendationsForEntity)(state, entityIdOrName, 'vendor');
+    // Cache hit: apply straight away, no request and no wait.
+    if (cached.fetchState === 'Completed') {
+        return (0, rxjs_1.of)((0, transactionDetailReducer_1.setRecommendationsForCreateTransactionLines)(transactionType, lineIds, cached.recommendations ?? [], isAccountingClassesEnabled));
+    }
+    const waitThenApply = actions$.pipe((0, operators_1.filter)(recommendationReducer_1.indicateReadyToInitializeRecommendation.match), (0, operators_1.filter)((ready) => ready.payload.entityType === 'vendor' &&
+        ready.payload.entityIdOrName === entityIdOrName), (0, operators_1.take)(1), // don't listen forever! IMPORTANT!
+    (0, operators_1.mergeMap)(() => (0, rxjs_1.from)([
+        (0, transactionDetailReducer_1.setRecommendationsForCreateTransactionLines)(transactionType, lineIds, (0, recommendationSelector_1.getRecommendationsForEntity)(state$.value, entityIdOrName, 'vendor').recommendations ?? [], (0, tenantSelector_1.getIsAccountingClassesEnabled)(state$.value)),
+    ])));
+    // A fetch already in flight needs no second request, only the wait.
+    if (cached.fetchState === 'In-Progress') {
+        return waitThenApply;
+    }
+    return (0, rxjs_1.concat)((0, rxjs_1.of)((isUnsyncedVendor(entity)
+        ? (0, recommendationReducer_1.fetchRecommendationByEntityName)(entityIdOrName, 'vendor')
+        : (0, recommendationReducer_1.fetchRecommendationByEntityId)(entityIdOrName, 'vendor'))), waitThenApply);
+}));
+exports.fetchVendorRecommendationsForCreateTransactionEpic = fetchVendorRecommendationsForCreateTransactionEpic;

package/lib/view/transactionDetail/createTransaction/epics/initializeCreateTransactionLocalDataEpic.d.ts

@@ -0,0 +1,12 @@
+import { ActionsObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { initializeCreateTransactionLocalData, resetCreateTransactionLocalData } from '../../transactionDetailReducer';
+export type ActionType = ReturnType<typeof initializeCreateTransactionLocalData> | ReturnType<typeof resetCreateTransactionLocalData>;
+/**
+ * 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 declare const initializeCreateTransactionLocalDataEpic: (actions$: ActionsObservable<ActionType>) => Observable<ActionType>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeCreateTransactionLocalDataEpic = void 0;
+const operators_1 = require("rxjs/operators");
+const transactionDetailReducer_1 = require("../../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.
+ */
+const initializeCreateTransactionLocalDataEpic = (actions$) => actions$.pipe((0, operators_1.filter)(transactionDetailReducer_1.initializeCreateTransactionLocalData.match), (0, operators_1.map)((action) => (0, transactionDetailReducer_1.resetCreateTransactionLocalData)(action.payload.transactionType)));
+exports.initializeCreateTransactionLocalDataEpic = initializeCreateTransactionLocalDataEpic;

package/lib/view/transactionDetail/transactionDetailReducer.d.ts

@@ -9,6 +9,7 @@ import { TransactionID } from '../../entity/transaction/stateTypes/transactionID
 import { SupportedTransaction, SupportedTransactionPayload } from '../../entity/transaction/transactionState';
 import { ZeniAPIStatus } from '../../responsePayload';
 import { UncategorizedAccounts } from '../accountList/accountListSelector';
+import { CreateTransactionLineLocalData, CreateTransactionLocalData } from './createTransaction/createTransactionState';
 import { TransactionDetailState, TransactionSaveUpdates } from './transactionDetailState';
 import { TransactionDetailLineItemData, TransactionDetailLocalData, TransactionVendorUpdates } from './transactionDetailTypes';
 export declare const initialState: TransactionDetailState;
@@ -176,6 +177,43 @@ export declare const downloadAccountingProviderAttachment: import("@reduxjs/tool
 }, "transactionDetail/deleteSplitLine", never, never>, toggleSplitEditMode: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionId: TransactionID, editMode: boolean], {
     transactionId: TransactionID;
     editMode: boolean;
-}, "transactionDetail/toggleSplitEditMode", never, never>;
+}, "transactionDetail/toggleSplitEditMode", never, never>, initializeCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/initializeCreateTransactionLocalData", never, never>, updateCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", localData: Partial<CreateTransactionLocalData>], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    localData: Partial<CreateTransactionLocalData>;
+}, "transactionDetail/updateCreateTransactionLocalData", never, never>, updateCreateTransactionLineLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineId: string, lineUpdates: Partial<CreateTransactionLineLocalData>], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineId: string;
+    lineUpdates: Partial<CreateTransactionLineLocalData>;
+}, "transactionDetail/updateCreateTransactionLineLocalData", never, never>, addCreateTransactionLine: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", line?: Partial<CreateTransactionLineLocalData> | undefined], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    line: Partial<CreateTransactionLineLocalData> | undefined;
+}, "transactionDetail/addCreateTransactionLine", never, never>, removeCreateTransactionLine: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineId: string], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineId: string;
+}, "transactionDetail/removeCreateTransactionLine", never, never>, resetCreateTransactionLocalData: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/resetCreateTransactionLocalData", never, never>, createTransaction: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry"], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+}, "transactionDetail/createTransaction", never, never>, createTransactionSuccessOrFailure: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[fetchState: FetchState, createdTransactionId?: TransactionID | undefined, error?: ZeniAPIStatus<Record<string, unknown>> | undefined], {
+    fetchState: FetchState;
+    createdTransactionId: TransactionID | undefined;
+    error: ZeniAPIStatus<Record<string, unknown>> | undefined;
+}, "transactionDetail/createTransactionSuccessOrFailure", never, never>, setRecommendationsForCreateTransactionLines: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[], recommendations: Recommendation[], isAccountingClassesEnabled: boolean], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+    recommendations: Recommendation[];
+    isAccountingClassesEnabled: boolean;
+}, "transactionDetail/setRecommendationsForCreateTransactionLines", never, never>, clearRecommendationsForCreateTransactionLines: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[]], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+}, "transactionDetail/clearRecommendationsForCreateTransactionLines", never, never>, fetchVendorRecommendationsForCreateTransaction: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry", lineIds: string[], entity?: Entity | undefined], {
+    transactionType: "expense" | "check" | "credit_card_credit" | "transfer" | "journal_entry";
+    lineIds: string[];
+    entity: Entity | undefined;
+}, "transactionDetail/fetchVendorRecommendationsForCreateTransaction", never, never>, createTransactionAttachmentUploadFailure: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[failedAttachmentFileNames: string[]], {
+    failedAttachmentFileNames: string[];
+}, "transactionDetail/createTransactionAttachmentUploadFailure", never, never>;
 declare const _default: import("redux").Reducer<TransactionDetailState>;
 export default _default;