@zeniai/client-epic-state 5.2.11-beta0ND → 5.2.11-betaAM2

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;

package/lib/esm/view/expenseAutomationView/reducers/actualMatchingViewReducer.js

@@ -0,0 +1,260 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
+import { generateJEOneTimeAccrualKey } from '../../../entity/jeSchedules/jeScheduleHelper';
+import { clearAll } from '../../../rootActions';
+export const initialTransactionSearchState = {
+    query: '',
+    results: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    nextPageToken: null,
+    isLoadingMore: false,
+};
+export const initialAccrualSearchState = {
+    query: '',
+    results: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    nextPageToken: null,
+    isLoadingMore: false,
+};
+export const initialMatchModalState = {
+    isOpen: false,
+    transactionSearch: initialTransactionSearchState,
+    accrualSearch: initialAccrualSearchState,
+    confirmStatus: { fetchState: 'Not-Started', error: undefined },
+};
+export const initialState = {
+    accrualKeysByPeriod: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    uiState: {
+        sortKey: 'date',
+        sortOrder: 'descending',
+        searchString: '',
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+    },
+    matchModal: initialMatchModalState,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+function resetMatchModalSearches(draft) {
+    draft.matchModal.transactionSearch = initialTransactionSearchState;
+    draft.matchModal.accrualSearch = initialAccrualSearchState;
+    draft.matchModal.confirmStatus = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    draft.matchModal.lastBatchResults = undefined;
+}
+const expenseAutomationActualMatchingView = createSlice({
+    name: 'expenseAutomationActualMatchingView',
+    initialState,
+    reducers: {
+        fetchActualMatchingPage: {
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+            reducer() {
+                // Epic-only fan-out.
+            },
+        },
+        fetchActualMatching: {
+            reducer(draft, action) {
+                const { refreshViewInBackground } = action.payload;
+                if (refreshViewInBackground) {
+                    draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+                }
+                else {
+                    draft.fetchState = 'In-Progress';
+                    draft.error = undefined;
+                }
+            },
+            prepare(period, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchActualMatchingSuccess(draft, action) {
+            const { accruals, selectedPeriod, refreshViewInBackground } = action.payload;
+            const periodId = toMonthYearPeriodId(selectedPeriod);
+            draft.accrualKeysByPeriod[periodId] = accruals.map((accrual) => generateJEOneTimeAccrualKey(accrual._id));
+            if (refreshViewInBackground) {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            else {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+        },
+        fetchActualMatchingFailure(draft, action) {
+            const { status, refreshViewInBackground } = action.payload;
+            if (refreshViewInBackground) {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+            }
+            else {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+        },
+        updateActualMatchingUIState(draft, action) {
+            if (action.payload.sortKey != null) {
+                draft.uiState.sortKey = action.payload.sortKey;
+            }
+            if (action.payload.sortOrder != null) {
+                draft.uiState.sortOrder = action.payload.sortOrder;
+            }
+            if (action.payload.searchString != null) {
+                draft.uiState.searchString = action.payload.searchString;
+            }
+            if (action.payload.scrollPosition != null) {
+                draft.uiState.scrollPosition = action.payload.scrollPosition;
+            }
+        },
+        openMatchNewModal(draft) {
+            draft.matchModal.isOpen = true;
+        },
+        closeMatchNewModal(draft) {
+            draft.matchModal.isOpen = false;
+            resetMatchModalSearches(draft);
+        },
+        clearMatchNewModal(draft) {
+            draft.matchModal.isOpen = false;
+            resetMatchModalSearches(draft);
+        },
+        searchMatchTransactions: {
+            reducer(draft, action) {
+                const { query, pageToken } = action.payload;
+                const isLoadMore = pageToken != null;
+                draft.matchModal.transactionSearch.query = query;
+                if (isLoadMore) {
+                    draft.matchModal.transactionSearch.isLoadingMore = true;
+                }
+                else {
+                    draft.matchModal.transactionSearch.isLoadingMore = false;
+                    draft.matchModal.transactionSearch.results = [];
+                    draft.matchModal.transactionSearch.nextPageToken = null;
+                    draft.matchModal.transactionSearch.fetchState = 'In-Progress';
+                    draft.matchModal.transactionSearch.error = undefined;
+                }
+            },
+            prepare({ query, pageToken }) {
+                return { payload: { query, pageToken: pageToken ?? undefined } };
+            },
+        },
+        searchMatchTransactionsSuccess(draft, action) {
+            const { append, nextPageToken, results } = action.payload;
+            if (append) {
+                const merged = [
+                    ...draft.matchModal.transactionSearch.results,
+                    ...results,
+                ];
+                const byKey = new Map(merged.map((result) => [
+                    `${result.transactionId}:${result.lineId}`,
+                    result,
+                ]));
+                draft.matchModal.transactionSearch.results = Array.from(byKey.values());
+            }
+            else {
+                draft.matchModal.transactionSearch.results = results;
+            }
+            draft.matchModal.transactionSearch.nextPageToken = nextPageToken;
+            draft.matchModal.transactionSearch.isLoadingMore = false;
+            draft.matchModal.transactionSearch.fetchState = 'Completed';
+            draft.matchModal.transactionSearch.error = undefined;
+        },
+        searchMatchTransactionsFailure(draft, action) {
+            draft.matchModal.transactionSearch.isLoadingMore = false;
+            draft.matchModal.transactionSearch.fetchState = 'Error';
+            draft.matchModal.transactionSearch.error = action.payload.error;
+        },
+        searchMatchAccruals: {
+            reducer(draft, action) {
+                const { query, pageToken } = action.payload;
+                const isLoadMore = pageToken != null;
+                draft.matchModal.accrualSearch.query = query;
+                if (isLoadMore) {
+                    draft.matchModal.accrualSearch.isLoadingMore = true;
+                }
+                else {
+                    draft.matchModal.accrualSearch.isLoadingMore = false;
+                    draft.matchModal.accrualSearch.results = [];
+                    draft.matchModal.accrualSearch.nextPageToken = null;
+                    draft.matchModal.accrualSearch.fetchState = 'In-Progress';
+                    draft.matchModal.accrualSearch.error = undefined;
+                }
+            },
+            prepare({ query, pageToken }) {
+                return { payload: { query, pageToken: pageToken ?? undefined } };
+            },
+        },
+        searchMatchAccrualsSuccess(draft, action) {
+            const { append, nextPageToken, results } = action.payload;
+            const keys = results.map((accrual) => generateJEOneTimeAccrualKey(accrual._id));
+            if (append) {
+                const merged = [...draft.matchModal.accrualSearch.results, ...keys];
+                draft.matchModal.accrualSearch.results = Array.from(new Set(merged));
+            }
+            else {
+                draft.matchModal.accrualSearch.results = keys;
+            }
+            draft.matchModal.accrualSearch.nextPageToken = nextPageToken;
+            draft.matchModal.accrualSearch.isLoadingMore = false;
+            draft.matchModal.accrualSearch.fetchState = 'Completed';
+            draft.matchModal.accrualSearch.error = undefined;
+        },
+        searchMatchAccrualsFailure(draft, action) {
+            draft.matchModal.accrualSearch.isLoadingMore = false;
+            draft.matchModal.accrualSearch.fetchState = 'Error';
+            draft.matchModal.accrualSearch.error = action.payload.error;
+        },
+        matchAndReverseAccruals: {
+            reducer(draft) {
+                draft.matchModal.confirmStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(params) {
+                return { payload: params };
+            },
+        },
+        matchAndReverseAccrualsSuccess(draft, action) {
+            draft.matchModal.confirmStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.matchModal.lastBatchResults = action.payload.results;
+        },
+        matchAndReverseAccrualsFailure(draft, action) {
+            draft.matchModal.confirmStatus = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        clearActualMatchingView(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+    extraReducers: (builder) => {
+        builder.addCase(clearAll, (draft) => {
+            Object.assign(draft, initialState);
+        });
+    },
+});
+export const { clearActualMatchingView, clearMatchNewModal, closeMatchNewModal, fetchActualMatching, fetchActualMatchingFailure, fetchActualMatchingPage, fetchActualMatchingSuccess, matchAndReverseAccruals, matchAndReverseAccrualsFailure, matchAndReverseAccrualsSuccess, openMatchNewModal, searchMatchAccruals, searchMatchAccrualsFailure, searchMatchAccrualsSuccess, searchMatchTransactions, searchMatchTransactionsFailure, searchMatchTransactionsSuccess, updateActualMatchingUIState, } = expenseAutomationActualMatchingView.actions;
+export default expenseAutomationActualMatchingView.reducer;