@zeniai/client-epic-state 5.1.72 → 5.1.73-betaRD2

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

@@ -0,0 +1,140 @@
+import { toAmount } from '../../../commonStateTypes/amount';
+import { DEFAULT_DATE_FORMAT } from '../../../commonStateTypes/fiscalYearHelpers/formatZeniDateFY';
+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/reducers/jeSchedulesViewReducer.js

@@ -2,8 +2,9 @@ import { createSlice } from '@reduxjs/toolkit';
 import { geNestedAccountIDHierarchyForReport } from '../../../commonStateTypes/accountView/getNestedAccountIDHierarchyForReport';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { mapAccountBasePayloadToAccountBase, mapAccountMetadataPayloadToAccountMetadata, } from '../../../entity/account/accountPayload';
-import { getJEScheduleTransactionDetailKeyPayload, } from '../../../entity/jeSchedules/jeSchedulesPayload';
+import { getJEScheduleKey, getJEScheduleTransactionDetailKeyPayload, } from '../../../entity/jeSchedules/jeSchedulesPayload';
 import { mapAccountTypeRecommendationPayloadToAccountRecommendationByType, } from '../../accountMappingView/accountTypeRecommendation/accountTypeRecommendationPayload';
+import { MIN_NEW_SCHEDULE_SEARCH_LENGTH, } from '../types/jeSchedulesViewState';
 export const accountSettingsInitialState = {
     localData: {
         selectedPrepaidExpensesAccountIds: [],
@@ -35,16 +36,33 @@ export const accountSettingsInitialState = {
     accruedExpensesNestedAccountListHierarchy: [],
     accruedExpensesRecommendations: [],
 };
+export const getBaseNewScheduleLocalData = (scheduleType) => ({
+    scheduleType,
+    jeScheduleDetails: [],
+});
+export const newScheduleInitialState = {
+    fixed_assets: getBaseNewScheduleLocalData('fixed_assets'),
+    prepaid_expenses: getBaseNewScheduleLocalData('prepaid_expenses'),
+};
+export const searchTransactionsInitialState = {
+    searchResults: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+};
 export const initialState = {
     jeScheduleTransactionKeysByPeriod: {},
+    jeScheduleAccruedKeysByPeriod: {},
     failedJeScheduleTransactionKeysByPeriod: {},
     postStatusById: {},
     ignoreStatusById: {},
     jeScheduleLocalDataById: {},
     uiState: {
-        searchString: '',
+        createdGroupCollapsed: false,
+        pendingGroupCollapsed: false,
         scrollPosition: { scrollTop: 0, scrollLeft: undefined },
-        selectedMainTab: 'pending_review',
+        searchString: '',
+        selectedJETypeFilter: null,
+        selectedPageTab: 'schedules',
         sortKey: 'transactionDate',
         sortOrder: 'descending',
         totalCount: 0,
@@ -55,6 +73,13 @@ export const initialState = {
         error: undefined,
     },
     accountSettings: accountSettingsInitialState,
+    newSchedule: {
+        newScheduleState: newScheduleInitialState,
+        saveStatus: { fetchState: 'Not-Started', error: undefined },
+        searchTransactions: searchTransactionsInitialState,
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     fetchState: 'Not-Started',
     error: undefined,
     hasValidState() {
@@ -99,9 +124,10 @@ const expenseAutomationJESchedulesView = createSlice({
             },
         },
         fetchJeSchedulesSuccess(draft, action) {
-            const { jeSchedules, selectedPeriod, failedJeSchedules, refreshViewInBackground, } = action.payload;
+            const { jeSchedules, selectedPeriod, failedJeSchedules, accruedJeSchedules, refreshViewInBackground, } = action.payload;
             const jeScheduleTransactionKeys = jeSchedules.map((schedules) => getJEScheduleTransactionDetailKeyPayload(schedules.base_transaction));
             const failedJeScheduleTransactionKeys = failedJeSchedules.map((schedules) => getJEScheduleTransactionDetailKeyPayload(schedules.base_transaction));
+            const jeScheduleAccruedKeys = accruedJeSchedules.map((schedule) => getJEScheduleKey(schedule));
             if (refreshViewInBackground === true &&
                 draft.refreshStatus.fetchState === 'In-Progress') {
                 draft.refreshStatus = { fetchState: 'Completed', error: undefined };
@@ -111,6 +137,8 @@ const expenseAutomationJESchedulesView = createSlice({
                 draft.error = undefined;
             }
             draft.jeScheduleTransactionKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] = jeScheduleTransactionKeys;
+            draft.jeScheduleAccruedKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] =
+                jeScheduleAccruedKeys;
             draft.failedJeScheduleTransactionKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] = failedJeScheduleTransactionKeys;
         },
         fetchJeSchedulesFailure(draft, action) {
@@ -121,8 +149,9 @@ const expenseAutomationJESchedulesView = createSlice({
             else {
                 draft.fetchState = 'Error';
                 draft.error = status;
+                draft.jeScheduleTransactionKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] = [];
+                draft.jeScheduleAccruedKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] = [];
             }
-            draft.jeScheduleTransactionKeysByPeriod[toMonthYearPeriodId(selectedPeriod)] = [];
         },
         retryJeSchedule(draft, action) {
             const { scheduledJournalEntryID } = action.payload;
@@ -368,6 +397,91 @@ const expenseAutomationJESchedulesView = createSlice({
         clearJeAccountSettingsLocalData(draft) {
             draft.accountSettings.localData = accountSettingsInitialState.localData;
         },
+        initializeNewSchedule: {
+            prepare({ scheduleType, }) {
+                return { payload: { scheduleType } };
+            },
+            reducer() {
+                // Purely an epic-trigger action — the epic fans out the account/class
+                // list fetches plus resetNewScheduleLocalData.
+            },
+        },
+        resetNewScheduleLocalData: {
+            prepare({ scheduleType, }) {
+                return { payload: { scheduleType } };
+            },
+            reducer(draft, action) {
+                const { scheduleType } = action.payload;
+                draft.newSchedule.newScheduleState[scheduleType] =
+                    getBaseNewScheduleLocalData(scheduleType);
+            },
+        },
+        updateNewScheduleLocalData(draft, action) {
+            const { scheduleType, localData } = action.payload;
+            draft.newSchedule.newScheduleState[scheduleType] = {
+                ...draft.newSchedule.newScheduleState[scheduleType],
+                ...localData,
+            };
+        },
+        searchTransactionsForNewSchedule: {
+            prepare({ query, scheduleType, }) {
+                return { payload: { query, scheduleType } };
+            },
+            reducer(draft, action) {
+                const trimmed = action.payload.query.trim();
+                // Cleared or too-short query: no API (see epic) — reset immediately.
+                if (trimmed.length < MIN_NEW_SCHEDULE_SEARCH_LENGTH) {
+                    draft.newSchedule.searchTransactions = searchTransactionsInitialState;
+                    return;
+                }
+                draft.newSchedule.searchTransactions = {
+                    ...draft.newSchedule.searchTransactions,
+                    searchString: action.payload.query,
+                    fetchState: 'In-Progress',
+                };
+            },
+        },
+        searchTransactionsForNewScheduleSuccess(draft, action) {
+            draft.newSchedule.searchTransactions = {
+                ...draft.newSchedule.searchTransactions,
+                searchResults: action.payload.searchResults,
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        searchTransactionsForNewScheduleFailure(draft, action) {
+            draft.newSchedule.searchTransactions = {
+                ...draft.newSchedule.searchTransactions,
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
+        clearSearchTransactionsForNewSchedule(draft) {
+            draft.newSchedule.searchTransactions = searchTransactionsInitialState;
+        },
+        saveNewSchedule: {
+            prepare({ scheduleType, }) {
+                return { payload: { scheduleType } };
+            },
+            reducer(draft) {
+                draft.newSchedule.saveStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+        },
+        saveNewScheduleSuccess(draft) {
+            draft.newSchedule.saveStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        saveNewScheduleFailure(draft, action) {
+            draft.newSchedule.saveStatus = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
         updateJESchedulesUIState(draft, action) {
             if (action.payload.sortKey != null) {
                 draft.uiState.sortKey = action.payload.sortKey;
@@ -381,16 +495,27 @@ const expenseAutomationJESchedulesView = createSlice({
             if (action.payload.scrollPosition != null) {
                 draft.uiState.scrollPosition = action.payload.scrollPosition;
             }
-            if (action.payload.selectedMainTab != null) {
-                draft.uiState.selectedMainTab = action.payload.selectedMainTab;
+            if (action.payload.selectedPageTab != null) {
+                draft.uiState.selectedPageTab = action.payload.selectedPageTab;
             }
         },
+        updateJEScheduleTypeFilter(draft, action) {
+            draft.uiState.selectedJETypeFilter = action.payload;
+        },
+        toggleJEPendingGroupCollapsed(draft) {
+            draft.uiState.pendingGroupCollapsed =
+                !draft.uiState.pendingGroupCollapsed;
+        },
+        toggleJECreatedGroupCollapsed(draft) {
+            draft.uiState.createdGroupCollapsed =
+                !draft.uiState.createdGroupCollapsed;
+        },
         clearExpenseAutomationJESchedulesView(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { clearExpenseAutomationJESchedulesView, clearJeAccountSettingsLocalData, clearJeScheduleLocalData, fetchAccountSettingsListForAccountTypes, fetchJeSchedules, fetchJeSchedulesFailure, fetchJeSchedulesPage, fetchJeSchedulesSuccess, fetchRecommendationForAccountSettings, ignoreRecommendedJeSchedule, ignoreRecommendedJeScheduleFailure, ignoreRecommendedJeScheduleSuccess, initializeAccountSettingsView, initializeJeScheduleLocalData, removeFailedJeScheduleTransactionKey, removeJeScheduleLocalDataById, removeJeScheduleTransactionKey, retryJeSchedule, retryJeScheduleFailure, retryJeScheduleSuccess, saveAccountSettings, saveAccountSettingsFailure, saveAccountSettingsLocalData, saveAccountSettingsSuccess, updateAccountSettingsListForAccountTypes, updateAccountSettingsListForAccountTypesFailure, updateJESchedulesUIState, updateJeScheduleLocalDataById, updateJeScheduleTransactionKeys, updateRecommendationForAccountSettings, updateRecommendationForAccountSettingsFailure, } = expenseAutomationJESchedulesView.actions;
+export const { clearExpenseAutomationJESchedulesView, clearJeAccountSettingsLocalData, clearJeScheduleLocalData, clearSearchTransactionsForNewSchedule, fetchAccountSettingsListForAccountTypes, fetchJeSchedules, fetchJeSchedulesFailure, fetchJeSchedulesPage, fetchJeSchedulesSuccess, fetchRecommendationForAccountSettings, ignoreRecommendedJeSchedule, ignoreRecommendedJeScheduleFailure, ignoreRecommendedJeScheduleSuccess, initializeAccountSettingsView, initializeJeScheduleLocalData, initializeNewSchedule, removeFailedJeScheduleTransactionKey, removeJeScheduleLocalDataById, removeJeScheduleTransactionKey, resetNewScheduleLocalData, retryJeSchedule, retryJeScheduleFailure, retryJeScheduleSuccess, saveAccountSettings, saveAccountSettingsFailure, saveAccountSettingsLocalData, saveAccountSettingsSuccess, saveNewSchedule, saveNewScheduleFailure, saveNewScheduleSuccess, searchTransactionsForNewSchedule, searchTransactionsForNewScheduleFailure, searchTransactionsForNewScheduleSuccess, toggleJECreatedGroupCollapsed, toggleJEPendingGroupCollapsed, updateAccountSettingsListForAccountTypes, updateAccountSettingsListForAccountTypesFailure, updateJESchedulesUIState, updateJEScheduleTypeFilter, updateJeScheduleLocalDataById, updateJeScheduleTransactionKeys, updateNewScheduleLocalData, updateRecommendationForAccountSettings, updateRecommendationForAccountSettingsFailure, } = expenseAutomationJESchedulesView.actions;
 export default expenseAutomationJESchedulesView.reducer;
 const doUpdateRecommendationForAccountSettings = (draft, payload) => {
     const { prepaidExpensesRecommendations, fixedAssetsRecommendations, accruedExpensesRecommendations, } = mapAccountTypeRecommendationPayloadToAccountRecommendationByType(payload);

package/lib/esm/view/expenseAutomationView/selectorTypes/jeNewScheduleViewSelectorTypes.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,70 @@
+import { getAccountIdsForTypes } from '../../../entity/account/accountSelector';
+import { getScheduleTransactionById } from '../../../entity/transaction/transactionSelector';
+import { getAccountIdsForLabel, getAccountList, getNestedAccountListHierarchy, } from '../../accountList/accountListSelector';
+import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
+import { getAccountsTypesForScheduleDetails } from '../../scheduleView/scheduleDetailView/scheduleDetailLocalDataHelper';
+import { filterNestedAccountHierarchyById } from '../../scheduleView/scheduleDetailView/scheduleDetailSelector';
+import { getAccountLabelForScheduleType, getAccountsTypesForScheduleEpics, } from '../../scheduleView/scheduleListView/scheduleListHelper';
+/**
+ * The Base Transaction search is shared across schedule types (one search
+ * box, not one per prepaid_expenses/fixed_assets) — split out from
+ * getNewScheduleView so a consumer can read it without supplying an
+ * otherwise-irrelevant scheduleType.
+ */
+export const getNewScheduleSearchTransactionsView = (state) => {
+    const { searchTransactions } = state.expenseAutomationJESchedulesViewState.newSchedule;
+    const searchTransactionsResults = searchTransactions.searchResults
+        .map((key) => getScheduleTransactionById(state.transactionState, key))
+        .filter((transaction) => transaction != null);
+    return {
+        searchTransactionsResults,
+        searchTransactionsFetchState: {
+            fetchState: searchTransactions.fetchState,
+            error: searchTransactions.error,
+        },
+        searchTransactionsString: searchTransactions.searchString,
+    };
+};
+export const getNewScheduleView = (state, scheduleType) => {
+    const { accountState, accountListState, classState, classListState } = state;
+    const { newSchedule } = state.expenseAutomationJESchedulesViewState;
+    const searchTransactionsView = getNewScheduleSearchTransactionsView(state);
+    const accountType = getAccountsTypesForScheduleEpics();
+    const newScheduleAccountTypes = getAccountsTypesForScheduleDetails(scheduleType);
+    const newScheduleAccountIds = getAccountIdsForTypes(accountState, newScheduleAccountTypes);
+    const allAccountList = getAccountList(accountState, accountListState, accountType.accountListKey);
+    const filteredAccounts = allAccountList.accounts.filter((account) => newScheduleAccountIds.includes(account.accountId));
+    const accountListNestedAccountHierarchy = filterNestedAccountHierarchyById(getNestedAccountListHierarchy(accountListState, accountType.accountListKey), filteredAccounts.map((account) => account.accountId));
+    const allClassList = getClassList(classState, classListState);
+    const classListNestedAccountHierarchy = getNestedClassListHierarchy(classListState);
+    let allDepreciationAccountList;
+    let allDepreciationAccountListNestedAccountHierarchy;
+    if (scheduleType === 'fixed_assets') {
+        const depreciationCategoryIds = getAccountIdsForTypes(accountState, [
+            'fixed_assets',
+            'other_assets',
+        ]);
+        const accountLabel = getAccountLabelForScheduleType('fixed_assets');
+        const fixedAssetLabelAccountIds = accountLabel != null
+            ? getAccountIdsForLabel(accountListState, accountType.accountListKey, accountLabel)
+            : [];
+        allDepreciationAccountList = allAccountList.accounts.filter((account) => depreciationCategoryIds.includes(account.accountId) &&
+            !fixedAssetLabelAccountIds.includes(account.accountId));
+        allDepreciationAccountListNestedAccountHierarchy =
+            filterNestedAccountHierarchyById(getNestedAccountListHierarchy(accountListState, accountType.accountListKey), allDepreciationAccountList.map((account) => account.accountId));
+    }
+    return {
+        scheduleType,
+        accountListNestedAccountHierarchy,
+        allAccountList: filteredAccounts,
+        allClassList: allClassList.classes,
+        allDepreciationAccountList,
+        allDepreciationAccountListNestedAccountHierarchy,
+        classListNestedAccountHierarchy,
+        newScheduleLocalData: newSchedule.newScheduleState[scheduleType],
+        saveStatus: newSchedule.saveStatus,
+        ...searchTransactionsView,
+        fetchState: newSchedule.fetchState,
+        error: newSchedule.error,
+    };
+};

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

@@ -3,7 +3,8 @@ import orderBy from 'lodash/orderBy';
 import { reduceAnyFetchState } from '../../../commonStateTypes/reduceFetchState';
 import { LAST_SCHEDULE_DAY_OF_MONTH, toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { getAccountIdsForTypes } from '../../../entity/account/accountSelector';
-import { getJEScheduledTransactionByJEScheduleTransactionKey, } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { getJEAccruedScheduleByJEScheduleKey, getJEScheduledTransactionByJEScheduleTransactionKey, } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { ALL_SCHEDULES_TYPES, } from '../../../entity/jeSchedules/jeSchedulesTypes';
 import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
 import { getAccountIdsForLabel, getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
@@ -12,6 +13,36 @@ import { filterNestedAccountHierarchyById } from '../../scheduleView/scheduleDet
 import { getAccountLabelForScheduleType, getAccountsTypesForScheduleList, } from '../../scheduleView/scheduleListView/scheduleListHelper';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 import { getJEAccountSettingsView } from './jeAccountSettingsViewSelector';
+import { getNewScheduleView } from './jeNewScheduleViewSelector';
+// Matches the AI-automation user addresses webc's schedule list row already
+// checks (JEScheduleReadOnlyListRow/JEScheduleDraftListRow "Method" column,
+// strings.ts aiBotEmail/botEmail) to determine whether a schedule was
+// created by the AI accountant vs. a human.
+const AI_BOT_EMAIL = 'ai@zeni.ai';
+const BOT_EMAIL = 'bot@zeni.ai';
+// Exported (rather than kept as a closure inside the selector) so it can be
+// unit-tested directly — confidenceScore is a separate, more narrowly
+// populated field that can be null on a schedule the bot user created,
+// which previously caused these schedules to display as "AI Accountant" in
+// the list but count under "Manual" in the KPI summary.
+export const isAiAccountantSchedule = (schedule) => schedule.createdByUser?.email === AI_BOT_EMAIL ||
+    schedule.createdByUser?.email === BOT_EMAIL;
+// Accrued schedules are structurally distinct — no baseTransaction, carrying recurringAmount and
+// memo in its place — so anything reading baseTransaction has to branch on this first.
+//
+// Discriminates on jeAccruedScheduleKey, which only JEAccruedSchedule carries. jeScheduleType
+// cannot be used: it is a data field present on BOTH row shapes, so an accrued-typed row that
+// arrived through the prepaid/fixed DTO (failed_je_postings, legacy fetches) would be
+// misclassified and then crash on recurringAmount / jeAccruedScheduleKey.
+export function isAccruedScheduleRow(schedule) {
+    return 'jeAccruedScheduleKey' in schedule;
+}
+function getScheduleAmount(schedule) {
+    if (isAccruedScheduleRow(schedule)) {
+        return schedule.recurringAmount.amount;
+    }
+    return schedule.baseTransaction.amount.amount;
+}
 function getJEScheduleSortAccessor(sortKey) {
     switch (sortKey) {
         case 'vendor':
@@ -23,7 +54,9 @@ function getJEScheduleSortAccessor(sortKey) {
         case 'depCategory':
             return (s) => s.jeCredit.account?.accountName?.toLowerCase();
         case 'scheduleCategory':
-            return (s) => s.baseTransaction.account?.accountName?.toLowerCase();
+            return (s) => isAccruedScheduleRow(s)
+                ? undefined
+                : s.baseTransaction.account?.accountName?.toLowerCase();
         case 'startMonth':
             return (s) => s.startDate?.valueOf();
         case 'type':
@@ -51,11 +84,13 @@ function getJEScheduleSortAccessor(sortKey) {
                 return s.balanceAsOfToday?.amount ?? null;
             };
         case 'totalAmount':
-            return (s) => s.baseTransaction.amount.amount;
+            return (s) => getScheduleAmount(s);
         case 'transactionDate':
-            return (s) => s.baseTransaction.date.valueOf();
+            return (s) => s.createTime?.valueOf();
         case 'memo':
-            return (s) => s.baseTransaction.memo?.toLowerCase();
+            return (s) => isAccruedScheduleRow(s)
+                ? s.memo.toLowerCase()
+                : s.baseTransaction.memo?.toLowerCase();
         default:
             return (s) => s.startDate?.valueOf();
     }
@@ -67,9 +102,14 @@ function sortJEScheduledTransactions(transactions, sortKey, sortOrder) {
 export function getExpenseAutomationJESchedulesView(state) {
     const jeScheduledTransaction = [];
     const failedJeScheduledTransaction = [];
+    const accruedSchedules = [];
     const { accountState, accountListState, classState, classListState, expenseAutomationJESchedulesViewState, expenseAutomationViewState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { jeScheduleTransactionKeysByPeriod, failedJeScheduleTransactionKeysByPeriod, jeScheduleLocalDataById, postStatusById, ignoreStatusById, uiState, error, fetchState, refreshStatus, } = expenseAutomationJESchedulesViewState;
+    const { jeScheduleTransactionKeysByPeriod, jeScheduleAccruedKeysByPeriod, failedJeScheduleTransactionKeysByPeriod, jeScheduleLocalDataById, postStatusById, ignoreStatusById, uiState, error, fetchState, refreshStatus, newSchedule, } = expenseAutomationJESchedulesViewState;
     const accountSettingsView = getJEAccountSettingsView(state);
+    const newScheduleView = newSchedule.selectedDetailScheduleType === 'fixed_assets' ||
+        newSchedule.selectedDetailScheduleType === 'prepaid_expenses'
+        ? getNewScheduleView(state, newSchedule.selectedDetailScheduleType)
+        : undefined;
     const currentTenant = getCurrentTenant(state);
     const { selectedPeriodByTenantId } = expenseAutomationViewState;
     const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
@@ -105,19 +145,24 @@ export function getExpenseAutomationJESchedulesView(state) {
         : null;
     const jeScheduleTransactionKeys = jeScheduleTransactionKeysForSelectedPeriod ?? [];
     const failedJeScheduleTransactionKeys = failedJeScheduleTransactionKeysForSelectedPeriod ?? [];
+    const jeScheduleAccruedKeys = (monthYearPeriodId != null
+        ? jeScheduleAccruedKeysByPeriod[monthYearPeriodId]
+        : null) ?? [];
     jeScheduleTransactionKeys.forEach((jeScheduleKey) => {
         const jeScheduleDetails = getJEScheduledTransactionByJEScheduleTransactionKey(jeScheduleKey, state);
         jeScheduledTransaction.push(jeScheduleDetails);
     });
+    jeScheduleAccruedKeys.forEach((jeAccruedScheduleKey) => {
+        const accruedScheduleDetails = getJEAccruedScheduleByJEScheduleKey(jeAccruedScheduleKey, state);
+        if (accruedScheduleDetails != null) {
+            accruedSchedules.push(accruedScheduleDetails);
+        }
+    });
     failedJeScheduleTransactionKeys.forEach((jeScheduleKey) => {
         const jeScheduleDetails = getJEScheduledTransactionByJEScheduleTransactionKey(jeScheduleKey, state);
         failedJeScheduledTransaction.push(jeScheduleDetails);
     });
-    const { sortKey, sortOrder } = uiState;
-    const draftSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'draft'), sortKey, sortOrder);
-    const ongoingSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'ongoing'), sortKey, sortOrder);
-    const completedSchedules = sortJEScheduledTransactions(jeScheduledTransaction.filter((schedule) => schedule.status.code === 'completed' ||
-        schedule.status.code === 'marked_as_completed'), sortKey, sortOrder);
+    const { sortKey, sortOrder, selectedJETypeFilter } = uiState;
     const unsortedResolveSchedules = [];
     failedJeScheduledTransaction.forEach((schedule) => {
         schedule.scheduledJournalEntry.forEach((journalEntry) => {
@@ -129,10 +174,46 @@ export function getExpenseAutomationJESchedulesView(state) {
     });
     const resolveSchedules = sortJEScheduledTransactions(unsortedResolveSchedules, sortKey, sortOrder);
     const validResolveForPending = unsortedResolveSchedules.filter((r) => jeScheduleLocalDataById[r.scheduledJournalEntry.scheduledJournalEntryID] != null);
+    const matchesTypeFilter = (schedule) => selectedJETypeFilter == null ||
+        schedule.jeScheduleType === selectedJETypeFilter;
+    const isCreatedStatus = (schedule) => schedule.status.code === 'ongoing' ||
+        schedule.status.code === 'completed' ||
+        schedule.status.code === 'marked_as_completed';
+    const allScheduleRows = [
+        ...jeScheduledTransaction,
+        ...accruedSchedules,
+    ];
     const pendingReviewSchedules = sortJEScheduledTransactions([
-        ...jeScheduledTransaction.filter((schedule) => schedule.status.code === 'draft'),
+        ...allScheduleRows.filter((schedule) => schedule.status.code === 'draft' && matchesTypeFilter(schedule)),
         ...validResolveForPending,
     ], sortKey, sortOrder);
+    const createdSchedules = sortJEScheduledTransactions(allScheduleRows.filter((schedule) => isCreatedStatus(schedule) && matchesTypeFilter(schedule)), sortKey, sortOrder);
+    // KPI summary — derived from unfiltered schedules so counts are always accurate
+    const allSchedules = allScheduleRows;
+    const sumAmount = (schedules) => schedules.reduce((total, schedule) => total + (getScheduleAmount(schedule) ?? 0), 0);
+    const pendingReviewTotal = sumAmount(pendingReviewSchedules);
+    const createdTotal = sumAmount(createdSchedules);
+    const aiAccountantSchedules = allSchedules.filter(isAiAccountantSchedule);
+    const manualSchedules = allSchedules.filter((schedule) => !isAiAccountantSchedule(schedule));
+    const pendingUnfiltered = allSchedules.filter((schedule) => schedule.status.code === 'draft');
+    const kpiSummary = {
+        aiAccountant: {
+            count: aiAccountantSchedules.length,
+            amount: sumAmount(aiAccountantSchedules),
+        },
+        manual: {
+            count: manualSchedules.length,
+            amount: sumAmount(manualSchedules),
+        },
+        needsReview: {
+            count: pendingUnfiltered.length,
+            amount: sumAmount(pendingUnfiltered),
+        },
+        total: {
+            count: allSchedules.length,
+            amount: sumAmount(allSchedules),
+        },
+    };
     const allSteps = monthYearPeriodId != null
         ? getAllSteps(monthEndCloseChecksState, monthYearPeriodId, currentTenant.tenantId)
         : [];
@@ -145,6 +226,22 @@ export function getExpenseAutomationJESchedulesView(state) {
         { fetchState, error },
         monthEndFetchState,
     ]);
+    const countByType = (schedules) => {
+        const counts = ALL_SCHEDULES_TYPES.reduce((acc, type) => ({ ...acc, [type]: 0 }), {});
+        schedules.forEach((schedule) => {
+            if (schedule.jeScheduleType != null) {
+                counts[schedule.jeScheduleType] += 1;
+            }
+        });
+        return counts;
+    };
+    const jeScheduleTypeCounts = {
+        active: countByType(allSchedules.filter((schedule) => schedule.status.code === 'draft' ||
+            schedule.status.code === 'ongoing' ||
+            schedule.status.code === 'completed' ||
+            schedule.status.code === 'marked_as_completed')),
+        ongoing: countByType(allSchedules.filter((schedule) => schedule.status.code === 'ongoing')),
+    };
     return {
         uncategorizedAccounts,
         allDepreciationAccountList: filteredDepAccounts,
@@ -153,12 +250,15 @@ export function getExpenseAutomationJESchedulesView(state) {
         allAccountList: filteredAccounts,
         accountListNestedAccountHierarchy,
         allClassList: allClasses,
-        completedSchedules,
-        draftSchedules,
-        ongoingSchedules,
+        createdSchedules,
+        createdTotal,
+        jeScheduleTypeCounts,
+        kpiSummary,
         pendingReviewSchedules,
+        pendingReviewTotal,
         resolveSchedules: resolveSchedules,
         accountSettingsView,
+        newScheduleView,
         postStatusById: postStatusById,
         ignoreStatusById: ignoreStatusById,
         fetchState: reducedFetchStatus.fetchState,

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

@@ -16,9 +16,6 @@ const JE_SCHEDULE_SORT_KEYS = [
     'memo',
 ];
 export const toJEScheduleSortKey = (v) => stringToUnion(v, JE_SCHEDULE_SORT_KEYS);
-const JE_SCHEDULE_MAIN_TABS = [
-    'pending_review',
-    'ongoing',
-    'completed',
-];
-export const toJEScheduleMainTab = (v) => stringToUnion(v, JE_SCHEDULE_MAIN_TABS);
+const JE_PAGE_TABS = ['schedules', 'existing_schedules'];
+export const toJEPageTab = (v) => stringToUnion(v, JE_PAGE_TABS);
+export const MIN_NEW_SCHEDULE_SEARCH_LENGTH = 2;