@zeniai/client-epic-state 5.2.10 → 5.2.11-betaAM1

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/oneTimeAccrualActionsEpic.js

@@ -0,0 +1,157 @@
+import { from, merge } from 'rxjs';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { convertToPeriod, toAbsoluteDay, } from '../../../../commonStateTypes/timePeriod';
+import { generateJEOneTimeAccrualKey } from '../../../../entity/jeSchedules/jeScheduleHelper';
+import { updateJEOneTimeAccruals } from '../../../../entity/jeSchedules/jeSchedulesReducer';
+import { getJEOneTimeAccrualByKey } from '../../../../entity/jeSchedules/jeSchedulesSelector';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { clearAll } from '../../../../rootActions';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchJeSchedules, ignoreOneTimeAccrual, oneTimeAccrualActionFailure, oneTimeAccrualActionSuccess, promoteOneTimeAccrual, revertOneTimeAccrual, } from '../../reducers/jeSchedulesViewReducer';
+/**
+ * The page the accrual came from, so a promoted or ignored row lands in the right bucket. Guarded
+ * because convertToPeriod destructures: an unset period would throw and take the epic subscription
+ * down for the session, and a missed refresh is the cheaper failure.
+ *
+ * Read state$.value at response time rather than the snapshot taken when the action was dispatched:
+ * if the user changes month while the request is in flight, the snapshot refreshes the month they
+ * have left and the month they are now looking at stays stale.
+ */
+function refreshCurrentPage(state) {
+    const selectedMonthYear = state.expenseAutomationViewState.selectedPeriodByTenantId[getCurrentTenant(state).tenantId];
+    if (selectedMonthYear == null) {
+        return [];
+    }
+    const period = convertToPeriod(selectedMonthYear);
+    const start = toAbsoluteDay(period.start);
+    const end = toAbsoluteDay(period.end);
+    if (start == null || end == null) {
+        return [];
+    }
+    return [fetchJeSchedules({ start, end }, true)];
+}
+function failureActions(
+// Per action, not fixed: every failure used to read "Save schedule failed", so skipping or
+// reverting an accrual reported an operation the user had not performed.
+messageSection, accrualId, message, status) {
+    return [
+        oneTimeAccrualActionFailure({
+            accrualId,
+            status: status ?? createZeniAPIStatus('Unexpected Error', message),
+        }),
+        openSnackbar({
+            messageSection,
+            messageText: 'failed',
+            type: 'error',
+            variables: [{ variableName: '_api-error_', variableValue: message }],
+        }),
+    ];
+}
+export const promoteOneTimeAccrualEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(promoteOneTimeAccrual.match), mergeMap((action) => {
+    const state = state$.value;
+    const { accrualId, amount } = action.payload;
+    const accrual = getJEOneTimeAccrualByKey(generateJEOneTimeAccrualKey(accrualId), state.jeSchedulesState);
+    if (accrual?.jeDebitAccountId == null ||
+        accrual.jeCreditAccountId == null) {
+        // Promote posts a journal entry, so it cannot proceed without both sides of it.
+        return from(failureActions('save_schedule', accrualId, 'This accrual is missing an expense or liability account.'));
+    }
+    // vendor_id, vendor_name and service_month are deliberately absent: promote takes them from
+    // the stored draft and ignores them in the body, so sending them would imply a reassignment
+    // that never happens.
+    const payload = {
+        amount,
+        memo: accrual.memo,
+        je_debit_account_id: accrual.jeDebitAccountId,
+        je_credit_account_id: accrual.jeCreditAccountId,
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accruals/${accrualId}`, { ...payload })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateJEOneTimeAccruals([response.data.accrual]),
+                oneTimeAccrualActionSuccess({ accrualId }),
+                openSnackbar({
+                    messageSection: 'save_schedule',
+                    messageText: 'success',
+                    type: 'success',
+                    variables: [
+                        {
+                            variableName: '_vendor_name_',
+                            variableValue: accrual.vendorName,
+                        },
+                    ],
+                }),
+                ...refreshCurrentPage(state$.value),
+            ]);
+        }
+        return from(failureActions('save_schedule', accrualId, response.status.message, response.status));
+    }), catchError((error) => from(failureActions('save_schedule', accrualId, `Promote accrual REST API call errored out ${JSON.stringify(error)}`))), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));
+export const ignoreOneTimeAccrualEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(ignoreOneTimeAccrual.match), mergeMap((action) => {
+    const { accrualId, reason, note } = action.payload;
+    // `scope` is deliberately never sent: the API returns 400 on it, which is why the design's
+    // "Apply to" selector cannot be built yet.
+    const payload = {
+        reason,
+        ...(note != null && note !== '' ? { note } : {}),
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accruals/${accrualId}/ignore`, { ...payload })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateJEOneTimeAccruals([response.data.accrual]),
+                oneTimeAccrualActionSuccess({ accrualId }),
+                openSnackbar({
+                    messageSection: 'ignore_accrual',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+                ...refreshCurrentPage(state$.value),
+            ]);
+        }
+        return from(failureActions('ignore_accrual', accrualId, response.status.message, response.status));
+    }), catchError((error) => from(failureActions('ignore_accrual', accrualId, `Ignore accrual REST API call errored out ${JSON.stringify(error)}`))), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));
+export const revertOneTimeAccrualEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(revertOneTimeAccrual.match), mergeMap((action) => {
+    const { accrualId, reason, note } = action.payload;
+    // Deletes the accrual's journal entry in QBO and soft-deletes the row. `scope` is never sent:
+    // the endpoint 400s on it, exactly as ignore does.
+    const payload = {
+        reason,
+        ...(note != null && note !== '' ? { note } : {}),
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/accruals/${accrualId}/revert`, { ...payload })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return from([
+                updateJEOneTimeAccruals([response.data.accrual]),
+                oneTimeAccrualActionSuccess({ accrualId }),
+                openSnackbar({
+                    messageSection: 'revert_accrual',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+                ...refreshCurrentPage(state$.value),
+            ]);
+        }
+        return from(failureActions('revert_accrual', accrualId, response.status.message, response.status));
+    }), catchError((error) => from(failureActions('revert_accrual', accrualId, `Revert accrual REST API call errored out ${JSON.stringify(error)}`))), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));
+export const oneTimeAccrualActionsEpic = (actions$, state$, zeniAPI) => merge(promoteOneTimeAccrualEpic(actions$, state$, zeniAPI), ignoreOneTimeAccrualEpic(actions$, state$, zeniAPI), revertOneTimeAccrualEpic(actions$, state$, zeniAPI));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/revertJeScheduleEpic.js

@@ -0,0 +1,111 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, takeUntil } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { clearAll } from '../../../../rootActions';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchMonthEndCloseChecks } from '../../../monthEndCloseChecksView/monthEndCloseChecksViewReducer';
+import { removeJeAccruedScheduleKey, removeJeScheduleTransactionKey, revertJeSchedule, revertJeScheduleFailure, revertJeScheduleSuccess, } from '../../reducers/jeSchedulesViewReducer';
+/**
+ * Undo a posted prepaid / fixed-asset / accrued schedule: deletes its posted QBO journal entry, then
+ * soft-deletes the scheduled entries and the schedule itself.
+ *
+ * Two or more posted journal entries answer 409 and leave the schedule intact, so the failure is
+ * surfaced rather than swallowed. Accrued has one extra rejection of its own — the endpoint refuses
+ * once a bill has been linked, because the reversal is already on the books — and that arrives the
+ * same way, as an error on the row.
+ *
+ * A one-time accrual is not this action: it is a Mongo row behind the accruals gateway, and goes
+ * through revertOneTimeAccrual instead. So `accrued_expenses` here always means an accrued
+ * *schedule*, which is what makes it a safe discriminator for the removal below.
+ */
+export const revertJeScheduleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(revertJeSchedule.match), mergeMap((action) => {
+    const state = state$.value;
+    const { expenseAutomationViewState: { selectedPeriodByTenantId }, } = state;
+    const { jeScheduleId, jeScheduleTransactionKey, reason, note, scheduleType } = action.payload;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    // Feedback nested under je_schedules[0], the same shape ignore takes -- the two endpoints were
+    // made symmetric server-side. A flat {reason, note} body, which this epic used to send while
+    // revert validated the whole body as feedback, now answers 400 "Request body must contain at
+    // least one of je_schedules".
+    //
+    // Only the id and the feedback: the rest of the fat blob is read from Datastore, not the
+    // request. The id is optional server-side but sent anyway, because it is validated against the
+    // URL and so turns a mismatch into a 400 rather than a revert of the wrong schedule.
+    // `action` is stamped server-side.
+    const payload = {
+        je_schedules: [
+            {
+                je_schedule_id: jeScheduleId,
+                feedback: {
+                    reason,
+                    ...(note != null && note !== '' ? { note } : {}),
+                },
+            },
+        ],
+    };
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/schedules/${jeScheduleId}/revert`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            // Deliberately not written to the entity store. A reverted schedule is soft-deleted,
+            // so the endpoint returns its flat entity json -- `vendor_id` as a bare field, no
+            // nested `vendor` or `base_transaction` -- rather than the list DTO those mappers
+            // expect. Feeding it to updateJESchedules threw inside doUpdateVendors on
+            // `payload.vendor.vendor_id`, and because that happens mid-dispatch it killed the
+            // rest of this array: the row kept spinning and no snackbar appeared. The row is
+            // removed from the list below regardless, so there is nothing worth storing.
+            return from([
+                revertJeScheduleSuccess({ jeScheduleTransactionKey }),
+                // Accrued keys live in their own per-tab map, so the transaction-key removal cannot
+                // reach them -- a reverted accrued schedule would sit on the list until the next
+                // fetch. The key carried here is a JEScheduleKey for that type.
+                scheduleType === 'accrued_expenses'
+                    ? removeJeAccruedScheduleKey(jeScheduleTransactionKey)
+                    : removeJeScheduleTransactionKey(jeScheduleTransactionKey, selectedPeriod),
+                fetchMonthEndCloseChecks({
+                    tenantId: currentTenant.tenantId,
+                    period: selectedPeriod,
+                    refreshViewInBackground: true,
+                }),
+                openSnackbar({
+                    messageSection: 'revert_schedule',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ]);
+        }
+        return from([
+            revertJeScheduleFailure({
+                jeScheduleTransactionKey,
+                status: response.status,
+            }),
+            openSnackbar({
+                messageSection: 'revert_schedule',
+                messageText: 'failed',
+                type: 'error',
+                variables: [
+                    {
+                        variableName: '_api-error_',
+                        variableValue: response.status.message,
+                    },
+                ],
+            }),
+        ]);
+    }), catchError((error) => from([
+        revertJeScheduleFailure({
+            jeScheduleTransactionKey,
+            status: createZeniAPIStatus('Unexpected Error', `Revert schedule REST API call errored out ${JSON.stringify(error)}`),
+        }),
+        openSnackbar({
+            messageSection: 'revert_schedule',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])), 
+    // A tenant switch clears the store while this request is still in flight.
+    // Without this the old tenant's response is written back into the freshly
+    // cleared store and stays on screen under the new tenant.
+    takeUntil(actions$.pipe(filter(clearAll.match))));
+}));

package/lib/esm/view/expenseAutomationView/epics/jeSchedule/switchJESchedulesTabEpic.js

@@ -0,0 +1,33 @@
+import { EMPTY, of } from 'rxjs';
+import { filter, mergeMap } from 'rxjs/operators';
+import { convertToPeriod, toAbsoluteDay, } from '../../../../commonStateTypes/timePeriod';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { fetchActualMatchingPage } from '../../reducers/actualMatchingViewReducer';
+import { fetchJeSchedulesPage, updateJESchedulesUIState, } from '../../reducers/jeSchedulesViewReducer';
+export const switchJESchedulesTabEpic = (actions$, state$) => actions$.pipe(filter(updateJESchedulesUIState.match), filter((action) => action.payload.selectedPageTab != null), mergeMap(() => {
+    const state = state$.value;
+    const { fetchState, refreshStatus } = state.expenseAutomationJESchedulesViewState;
+    if (fetchState === 'In-Progress' ||
+        refreshStatus.fetchState === 'In-Progress') {
+        return EMPTY;
+    }
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = state.expenseAutomationViewState.selectedPeriodByTenantId[currentTenant.tenantId];
+    // convertToPeriod destructures, so an unset period throws and takes this epic's subscription
+    // down for the rest of the session -- every later tab switch would then stop refreshing. A
+    // skipped refresh is the cheaper failure, as in refreshCurrentPage.
+    if (selectedPeriod == null) {
+        return EMPTY;
+    }
+    const period = convertToPeriod(selectedPeriod);
+    const timePeriodStart = toAbsoluteDay(period.start);
+    const timePeriodEnd = toAbsoluteDay(period.end);
+    if (timePeriodStart == null || timePeriodEnd == null) {
+        return EMPTY;
+    }
+    const { selectedPageTab } = state.expenseAutomationJESchedulesViewState.uiState;
+    if (selectedPageTab === 'actual_matching') {
+        return of(fetchActualMatchingPage({ start: timePeriodStart, end: timePeriodEnd }, true));
+    }
+    return of(fetchJeSchedulesPage({ start: timePeriodStart, end: timePeriodEnd }, true));
+}));

package/lib/esm/view/expenseAutomationView/expenseAutomationViewSelector.js

@@ -4,6 +4,7 @@ import { getMonthEndCloseChecksForATenantForSelectedPeriod } from '../../entity/
 import { getCurrentTenant, } from '../../entity/tenant/tenantSelector';
 import { getCompanyMonthEndReportSelectorView } from '../companyMonthEndReportView/companyMonthEndReportViewSelector';
 import { getMonthEndCloseChecksViewByTenantId, isMonthEndInsightDisabled, } from '../monthEndCloseChecksView/monthEndCloseChecksViewSelector';
+import { getExpenseAutomationActualMatchingView } from './selectors/actualMatchingViewSelector';
 import { getExpenseAutomationFluxAnalysisView } from './selectors/fluxAnalysisViewSelector';
 import { getAllSteps } from './selectors/getAllStepsHelper';
 import { getExpenseAutomationJESchedulesView } from './selectors/jeSchedulesViewSelector';
@@ -21,7 +22,7 @@ const isPreviousStepDisabled = (selectedTransactionCategorizationTab, allSteps,
     return allSteps[stepIndex - 1].isDisabled;
 };
 export function getExpenseAutomationView(state) {
-    const { expenseAutomationViewState, tenantState, expenseAutomationMissingReceiptsViewState, expenseAutomationJESchedulesViewState, expenseAutomationTransactionsViewState, expenseAutomationReconciliationViewState, monthEndCloseChecksState, companyState, } = state;
+    const { expenseAutomationViewState, tenantState, expenseAutomationMissingReceiptsViewState, expenseAutomationJESchedulesViewState, expenseAutomationActualMatchingViewState, expenseAutomationTransactionsViewState, expenseAutomationReconciliationViewState, monthEndCloseChecksState, companyState, } = state;
     const { loggedInUser, currentTenantId } = tenantState;
     const currentTenant = getCurrentTenant(state);
     const { currentSelectedView, selectedPeriodByTenantId } = expenseAutomationViewState;
@@ -42,6 +43,7 @@ export function getExpenseAutomationView(state) {
     const reconciliation = getExpenseAutomationReconciliationView(state);
     const expenseAutomationTransactionsView = getExpenseAutomationTransactionView(state);
     const jeSchedules = getExpenseAutomationJESchedulesView(state);
+    const actualMatching = getExpenseAutomationActualMatchingView(state);
     switch (currentSelectedView) {
         case 'reconciliation':
             currentSelectedViewFetchState = reconciliation.fetchStatus;
@@ -54,12 +56,23 @@ export function getExpenseAutomationView(state) {
                 fluxAnalysis.refreshStatus;
             break;
         case 'je_schedules':
-            currentSelectedViewFetchState = {
-                fetchState: jeSchedules.fetchState,
-                error: jeSchedules.error,
-            };
-            currentSelectedViewBackgroundRefreshFetchState =
-                jeSchedules.refreshStatus;
+            if (expenseAutomationJESchedulesViewState.uiState.selectedPageTab ===
+                'actual_matching') {
+                currentSelectedViewFetchState = {
+                    fetchState: actualMatching.fetchState,
+                    error: actualMatching.error,
+                };
+                currentSelectedViewBackgroundRefreshFetchState =
+                    actualMatching.refreshStatus;
+            }
+            else {
+                currentSelectedViewFetchState = {
+                    fetchState: jeSchedules.fetchState,
+                    error: jeSchedules.error,
+                };
+                currentSelectedViewBackgroundRefreshFetchState =
+                    jeSchedules.refreshStatus;
+            }
             break;
         case 'missing_receipts':
             currentSelectedViewFetchState = {
@@ -91,6 +104,7 @@ export function getExpenseAutomationView(state) {
     const fetchStateVariables = [
         expenseAutomationMissingReceiptsViewState,
         expenseAutomationJESchedulesViewState,
+        expenseAutomationActualMatchingViewState,
         expenseAutomationTransactionsView,
         expenseAutomationReconciliationViewState,
     ];
@@ -176,6 +190,7 @@ export function getExpenseAutomationView(state) {
     ]);
     return {
         jeSchedules,
+        actualMatching,
         transactionView: expenseAutomationTransactionsView,
         missingReceipts,
         reconciliation,

package/lib/esm/view/expenseAutomationView/helpers/newScheduleLocalDataHelper.js

@@ -0,0 +1,140 @@
+import { toAmount } from '../../../commonStateTypes/amount';
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { MONTH_YEAR_FORMAT } from '../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY';
+import { LAST_SCHEDULE_DAY_OF_MONTH } from '../../../commonStateTypes/timePeriod';
+import { getPostingDateAndStatusForIndex } from '../../scheduleView/scheduleDetailView/scheduleDetailLocalDataHelper';
+import { mapScheduleTransactionToBaseScheduleTransactionPayload, } from '../../scheduleView/scheduleDetailView/scheduleDetailPayload';
+const getNewScheduleMemo = (vendorName, schedulePostingDate, currentPeriod, totalPeriod, assetId) => {
+    const addAsset = assetId != null && assetId !== '' ? ` - ${assetId}` : '';
+    return `${vendorName} - ${schedulePostingDate.format(MONTH_YEAR_FORMAT)} (${currentPeriod} of ${totalPeriod})${addAsset}`;
+};
+/**
+ * Computes the month-by-month JE schedule breakdown for a brand-new schedule
+ * (no linked transaction yet) — replicates createNewSchedulesHelper's math
+ * (scheduleDetailLocalDataHelper.ts) exactly: lump-sum total split evenly
+ * across months with the rounding remainder absorbed by the last month, and a
+ * running balance that decrements each month and is forced to exactly 0 on
+ * the last row.
+ */
+export const computeNewScheduleJeDetails = (localData, totalAmount, vendorName) => {
+    const period = localData.selectedMonths;
+    const startingMonth = localData.selectedDate;
+    if (startingMonth == null || period == null) {
+        return [];
+    }
+    const assetId = 'assetId' in localData ? localData.assetId : undefined;
+    const averageAmount = Math.abs(Math.round((totalAmount.amount / period) * 100) / 100);
+    const lastMonthAmount = Math.abs(Math.round((Math.abs(totalAmount.amount) - averageAmount * (period - 1)) * 100) / 100);
+    let runningBalance = Math.abs(totalAmount.amount);
+    const negativeNumbers = totalAmount.amount < 0 || runningBalance < 0;
+    const newJeDetails = [];
+    for (let index = 0; index < period; index++) {
+        if (runningBalance > averageAmount) {
+            runningBalance = Math.round((runningBalance - averageAmount) * 100) / 100;
+        }
+        else {
+            runningBalance = 0;
+        }
+        const amount = index === period - 1 ? lastMonthAmount : averageAmount;
+        runningBalance = index === period - 1 ? 0 : runningBalance;
+        const schedulePostingDate = startingMonth.add(index, 'month');
+        const { postingDate, postingStatus } = getPostingDateAndStatusForIndex(schedulePostingDate.month(), schedulePostingDate.year(), localData.lastDayOfMonth === true
+            ? undefined
+            : localData.selectedDayOfMonth);
+        newJeDetails.push({
+            postingDate,
+            amount: toAmount(negativeNumbers ? -amount : amount, totalAmount.currencyCode, totalAmount.currencySymbol),
+            runningBalance: toAmount(negativeNumbers ? -runningBalance : runningBalance, totalAmount.currencyCode, totalAmount.currencySymbol),
+            postingStatus,
+            memo: getNewScheduleMemo(vendorName, schedulePostingDate, index + 1, period, assetId),
+            jeLink: { type: 'unknown' },
+        });
+    }
+    return newJeDetails;
+};
+const mapNewJeDetailsToScheduledJournalEntryPayload = (jeScheduleDetails) => jeScheduleDetails.map((journalEntry) => ({
+    status: {
+        code: journalEntry.postingStatus,
+        label: journalEntry.postingStatus,
+    },
+    transaction_memo: journalEntry.memo,
+    third_party_id: journalEntry.jeLink.thirdPartyTransactionId ?? null,
+    expected_post_date: journalEntry.postingDate.format(DEFAULT_DATE_FORMAT),
+    amount: journalEntry.amount.amount,
+    balance: journalEntry.runningBalance.amount,
+    // Brand-new schedule — there is no prior scheduled-journal-entry history
+    // to cross-reference (unlike the legacy edit flow's equivalent mapper).
+    scheduled_journal_entry_id: null,
+    actual_post_date: null,
+    is_platform_generated: null,
+    je_schedule_id: null,
+    update_time: null,
+    create_time: null,
+}));
+/**
+ * Builds a savable schedule payload directly from a Base Transaction search
+ * result and the New Schedule form's local data — bypassing the legacy
+ * getJEScheduledTransactionByJEScheduleTransactionKey selector entirely,
+ * since that selector throws unless the entity has already round-tripped
+ * through a real GET /1.0/schedules/:id. A brand-new schedule has no such
+ * history, so this reads only from data already in hand (the selected
+ * transaction/line plus what the user filled into the form).
+ */
+export const prepareNewSchedulePayload = (transaction, localData, scheduleType) => {
+    if (transaction.thirdPartyTransactionId == null ||
+        transaction.thirdPartyTransactionId === '') {
+        return { ok: false, reason: 'missing_third_party_id' };
+    }
+    const scheduleTransaction = transaction;
+    const vendorId = localData.selectedVendor?.id ?? transaction.vendorId ?? '';
+    const vendorName = localData.selectedVendor?.name ?? transaction.vendorName ?? '';
+    if (vendorId === '' || vendorName === '') {
+        return { ok: false, reason: 'missing_vendor' };
+    }
+    const vendor = {
+        vendor_id: vendorId,
+        vendor_name: vendorName,
+    };
+    const jeScheduleDetails = computeNewScheduleJeDetails(localData, scheduleTransaction.amount, vendorName);
+    const postingDate = localData.selectedDayOfMonth ??
+        (localData.lastDayOfMonth === true ? LAST_SCHEDULE_DAY_OF_MONTH : null);
+    const firstJEScheduleDate = jeScheduleDetails.length > 0
+        ? jeScheduleDetails[0].postingDate.format(DEFAULT_DATE_FORMAT)
+        : null;
+    const lastJEScheduleDate = jeScheduleDetails.length > 0
+        ? jeScheduleDetails[jeScheduleDetails.length - 1].postingDate.format(DEFAULT_DATE_FORMAT)
+        : null;
+    const isFixedAssets = scheduleType === 'fixed_assets';
+    const assetId = 'assetId' in localData ? localData.assetId : undefined;
+    const selectedAccumulatedDepreciationCategory = 'selectedAccumulatedDepreciationCategory' in localData
+        ? localData.selectedAccumulatedDepreciationCategory
+        : undefined;
+    const status = { code: 'new', label: 'New' };
+    const jeSchedulePayload = {
+        status,
+        vendor,
+        currency_code: scheduleTransaction.currency.currencyCode,
+        currency_symbol: scheduleTransaction.currency.currencySymbol,
+        period: localData.selectedMonths ?? null,
+        je_schedule_type: scheduleType,
+        posting_date: postingDate,
+        balance: scheduleTransaction.amount.amount,
+        start_date: firstJEScheduleDate,
+        end_date: lastJEScheduleDate,
+        je_credit_accounting_class_id: scheduleTransaction.classBase?.classId ?? null,
+        je_credit_account_id: isFixedAssets
+            ? (selectedAccumulatedDepreciationCategory ?? null)
+            : scheduleTransaction.account.accountId,
+        je_debit_account_id: localData.selectedAccount ?? null,
+        je_debit_accounting_class_id: localData.selectedClass ?? null,
+        other_attributes: assetId != null ? { asset_id: assetId } : {},
+        base_transaction: mapScheduleTransactionToBaseScheduleTransactionPayload(scheduleTransaction),
+    };
+    return {
+        ok: true,
+        payload: {
+            je_schedules: [jeSchedulePayload],
+            scheduled_journal_entries: mapNewJeDetailsToScheduledJournalEntryPayload(jeScheduleDetails),
+        },
+    };
+};

package/lib/esm/view/expenseAutomationView/payload/actualMatchingPayload.js

@@ -0,0 +1,35 @@
+import { toString } from '../../../commonStateTypes/timePeriod';
+import { toMatchAndReverseResultStatus, } from '../types/actualMatchingViewState';
+export function toServiceMonthFromPeriod(period) {
+    return toString(period.start).slice(0, 7);
+}
+const DEFAULT_CURRENCY_CODE = 'USD';
+const DEFAULT_CURRENCY_SYMBOL = '$';
+export function toActualMatchingTransactionSearchResult(payload) {
+    const currencyCode = payload.currency_code ?? DEFAULT_CURRENCY_CODE;
+    return {
+        transactionId: payload.transaction_id,
+        transactionIntegrationId: payload.transaction_integration_id,
+        transactionType: payload.transaction_type,
+        lineId: payload.line_id,
+        vendorId: payload.vendor_id ?? undefined,
+        vendorName: payload.vendor_name ?? '',
+        amount: payload.total_amount,
+        transactionDate: payload.transaction_date,
+        accountId: payload.account_id ?? undefined,
+        accountName: payload.account_name ?? undefined,
+        currencyCode,
+        currencySymbol: payload.currency_symbol ??
+            (currencyCode === DEFAULT_CURRENCY_CODE
+                ? DEFAULT_CURRENCY_SYMBOL
+                : currencyCode),
+        transactionMemo: payload.transaction_memo ?? undefined,
+    };
+}
+export function toMatchAndReverseResult(payload) {
+    return {
+        accrualId: payload.accrual_id,
+        status: toMatchAndReverseResultStatus(payload.status),
+        reason: payload.reason ?? undefined,
+    };
+}

package/lib/esm/view/expenseAutomationView/payload/jeSchedulesPayload.js

@@ -1,5 +1,60 @@
 import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/timePeriod';
+import { getClassList } from '../../classList/classListSelector';
 import { mapScheduleTransactionToBaseScheduleTransactionPayload, mapVendorToVendorPayload, } from '../../scheduleView/scheduleDetailView/scheduleDetailPayload';
+const BALANCE_SHEET_CLASS_LABEL = 'balance_sheet';
+const SERVICE_MONTH_FORMAT = 'YYYY-MM';
+/**
+ * The credit line is the accrued liability, which always sits on the balance sheet — the
+ * recurring accrued path resolves the same class the same way (see
+ * prepareNewScheduleAccruedDetailPayload). Omitted rather than sent empty when the tenant has
+ * no balance_sheet class, since the API treats the field as optional.
+ */
+export const prepareCreateOneTimeAccrualPayload = (state, localData) => {
+    const { classListState, classState } = state;
+    const balanceSheetClass = getClassList(classState, classListState).classes.find((accountingClass) => accountingClass.labels?.includes(BALANCE_SHEET_CLASS_LABEL) === true);
+    // reverse_next_month alone decides reversal_policy server-side, so reversal_policy is
+    // deliberately not sent — the API documents it only as an alternate way to say on_bill_match,
+    // and sending both would be two sources of truth for one toggle.
+    const reversalFields = localData.reverseNextMonth
+        ? {
+            reverse_next_month: true,
+            expected_reversal_date: getExpectedReversalDate(localData.serviceMonth).format(DEFAULT_DATE_FORMAT),
+        }
+        : { reverse_next_month: false };
+    return {
+        vendor_id: localData.vendorId,
+        vendor_name: localData.vendorName,
+        service_month: localData.serviceMonth.format(SERVICE_MONTH_FORMAT),
+        amount: localData.amount,
+        memo: localData.memo,
+        je_debit_account_id: localData.debitAccountId,
+        je_credit_account_id: localData.creditAccountId,
+        ...(localData.debitAccountName != null
+            ? { je_debit_account_name: localData.debitAccountName }
+            : {}),
+        ...(localData.creditAccountName != null
+            ? { je_credit_account_name: localData.creditAccountName }
+            : {}),
+        ...(localData.debitClassId != null
+            ? { je_debit_accounting_class_id: localData.debitClassId }
+            : {}),
+        ...(localData.debitClassName != null
+            ? { je_debit_accounting_class_name: localData.debitClassName }
+            : {}),
+        ...(balanceSheetClass != null
+            ? {
+                je_credit_accounting_class_id: balanceSheetClass.classId,
+                je_credit_accounting_class_name: balanceSheetClass.className,
+            }
+            : {}),
+        ...reversalFields,
+    };
+};
+/**
+ * The API defaults this to the 1st of the month after service_month. We send it explicitly so the
+ * date the form promised the user is the date that gets stored.
+ */
+export const getExpectedReversalDate = (serviceMonth) => serviceMonth.add(1, 'month').startOf('month');
 export const prepareIgnoreSchedulePayload = (scheduleType, jeScheduleTransaction, state) => {
     const { vendorState } = state;
     const { vendor, currencyCode, currencySymbol, baseTransaction, status, balanceAsOfToday, period, startDate, endDate, jeCredit, jeDebit, } = jeScheduleTransaction;