@zeniai/client-epic-state 4.13.15 → 4.13.16

package/lib/view/expenseAutomationView/reducers/missingReceiptsViewReducer.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearExpenseAutomationMissingReceiptsView = exports.markMissingReceiptAsDone = exports.updateMissingReceiptsUIState = exports.updateMissingReceiptUploadState = exports.uploadMissingReceiptSuccess = exports.fetchMissingReceiptsFailure = exports.fetchMissingReceiptsSuccess = exports.fetchMissingReceipts = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+exports.initialState = {
+    uploadReceiptStatusById: {},
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    uiState: {
+        sortKey: 'date',
+        sortOrder: 'descending',
+        searchString: '',
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+    },
+    transactionIdsBySelectedPeriod: {},
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationMissingReceiptsView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationMissingReceiptsView',
+    initialState: exports.initialState,
+    reducers: {
+        fetchMissingReceipts: {
+            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, minimumTransactionAmount, cacheOverride = false, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        period,
+                        minimumTransactionAmount,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        fetchMissingReceiptsSuccess(draft, action) {
+            const { transactionsPayload, selectedPeriod } = action.payload;
+            const transactionIds = transactionsPayload.map((transactionPayload) => transactionPayload.transaction_id);
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIds;
+        },
+        fetchMissingReceiptsFailure(draft, action) {
+            const { status, selectedPeriod } = action.payload;
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Error';
+                draft.error = status;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Error', error: status };
+            }
+            draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+        },
+        updateMissingReceiptsUIState(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;
+            }
+        },
+        updateMissingReceiptUploadState: {
+            reducer(draft, action) {
+                const { transactionId, fetchStatus } = action.payload;
+                draft.uploadReceiptStatusById[transactionId] = fetchStatus;
+            },
+            prepare(transactionId, fetchStatus) {
+                return { payload: { transactionId, fetchStatus } };
+            },
+        },
+        uploadMissingReceiptSuccess: {
+            reducer(draft, action) {
+                const { transactionPayload } = action.payload;
+                draft.uploadReceiptStatusById[transactionPayload.transaction_id] = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            },
+            prepare(transactionPayload, updateType = 'merge') {
+                return { payload: { transactionPayload, updateType } };
+            },
+        },
+        markMissingReceiptAsDone: {
+            reducer(draft, action) {
+                const { transactionPayload, selectedPeriod } = action.payload;
+                if (draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] != null) {
+                    draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)].filter((transactionId) => transactionId !== transactionPayload.transaction_id);
+                }
+                else {
+                    draft.transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+                }
+            },
+            prepare(transactionPayload, selectedPeriod) {
+                return { payload: { transactionPayload, selectedPeriod } };
+            },
+        },
+        clearExpenseAutomationMissingReceiptsView(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = expenseAutomationMissingReceiptsView.actions, exports.fetchMissingReceipts = _a.fetchMissingReceipts, exports.fetchMissingReceiptsSuccess = _a.fetchMissingReceiptsSuccess, exports.fetchMissingReceiptsFailure = _a.fetchMissingReceiptsFailure, exports.uploadMissingReceiptSuccess = _a.uploadMissingReceiptSuccess, exports.updateMissingReceiptUploadState = _a.updateMissingReceiptUploadState, exports.updateMissingReceiptsUIState = _a.updateMissingReceiptsUIState, exports.markMissingReceiptAsDone = _a.markMissingReceiptAsDone, exports.clearExpenseAutomationMissingReceiptsView = _a.clearExpenseAutomationMissingReceiptsView;
+exports.default = expenseAutomationMissingReceiptsView.reducer;

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.d.ts

@@ -0,0 +1,5 @@
+import { TransactionsViewState } from '../types/transactionsViewState';
+export declare const initialState: TransactionsViewState;
+export declare const clearExpenseAutomationTransactionsView: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<string>;
+declare const _default: import("@reduxjs/toolkit").Reducer<TransactionsViewState, import("@reduxjs/toolkit").AnyAction>;
+export default _default;

package/lib/view/expenseAutomationView/reducers/transactionsViewReducer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearExpenseAutomationTransactionsView = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+exports.initialState = {
+    saveStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    updateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    uiState: {
+        sortKey: 'vendor',
+        sortOrder: 'ascending',
+        searchString: '',
+        nodeCollapseState: {},
+        scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+        pageToken: null,
+        totalCount: 0,
+        limit: 10,
+    },
+    selectedTab: 'review',
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};
+const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
+    name: 'expenseAutomationTransactionsView',
+    initialState: exports.initialState,
+    reducers: {
+        clearExpenseAutomationTransactionsView() {
+            // TODO - Vivek
+        },
+    },
+});
+exports.clearExpenseAutomationTransactionsView = expenseAutomationTransactionsView.actions.clearExpenseAutomationTransactionsView;
+exports.default = expenseAutomationTransactionsView.reducer;

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.d.ts

@@ -0,0 +1,34 @@
+import { CompletionStatusType, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { MonthYearPeriod, MonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { MonthEndAuditSummary, MonthEndCloseChecksState } from '../../../entity/monthEndCloseChecks/monthEndCloseChecksState';
+import { MonthEndCloseChecksView } from '../../../view/monthEndCloseChecksView/monthEndCloseChecksViewSelector';
+import { CompanyMonthEndReportSelectorView } from '../../companyMonthEndReportView/companyMonthEndReportViewSelector';
+import { ExpenseAutomationViewType } from '../expenseAutomationViewState';
+import { ExpenseAutomationJESchedulesViewSelector } from './jeSchedulesSelectorTypes';
+import { ExpenseAutomationFluxAnalysisViewSelector } from './fluxAnalysisViewSelectorTypes';
+import { ExpenseAutomationMissingReceiptsViewSelector } from './missingReceiptsSelectorTypes';
+export interface ExpenseAutomationStepDetails {
+    step: ExpenseAutomationViewType;
+    title: string;
+    subTitle: string;
+    completionStatus: CompletionStatusType;
+    isDisabled: boolean;
+    isPrevDisabled: boolean;
+    isNextDisabled: boolean;
+}
+export declare const getAllSteps: (monthEndCloseChecksState: MonthEndCloseChecksState, monthYearId: MonthYearPeriodId, tenantId: ID, auditSummary?: MonthEndAuditSummary | undefined) => ExpenseAutomationStepDetails[];
+export interface ExpenseAutomationViewSelector extends SelectorView {
+    currentSelectedView: ExpenseAutomationViewType;
+    selectedPeriod: MonthYearPeriod;
+    monthEndCloseChecksView: MonthEndCloseChecksView;
+    jeSchedules: ExpenseAutomationJESchedulesViewSelector;
+    missingReceipts: ExpenseAutomationMissingReceiptsViewSelector;
+    fluxAnalysis: ExpenseAutomationFluxAnalysisViewSelector;
+    monthEndInsights?: CompanyMonthEndReportSelectorView;
+    saveStatus: FetchStateAndError;
+    updateStatus: FetchStateAndError;
+    allSteps: ExpenseAutomationStepDetails[];
+    completionStatus: CompletionStatusType;
+    auditSummary?: MonthEndAuditSummary;
+}

package/lib/view/expenseAutomationView/selectorTypes/expenseAutomationViewSelectorTypes.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllSteps = void 0;
+const common_1 = require("../../../commonStateTypes/common");
+const getAllSteps = (monthEndCloseChecksState, monthYearId, tenantId, auditSummary) => {
+    var _a;
+    if (((_a = monthEndCloseChecksState.monthEndCloseChecksByTenantId[tenantId]) === null || _a === void 0 ? void 0 : _a[monthYearId]) != null) {
+        const steps = monthEndCloseChecksState.monthEndCloseChecksByTenantId[tenantId][monthYearId].monthEndCloseCheckList.map((check) => {
+            switch (check.id) {
+                case 'month_end_insights':
+                    return {
+                        step: check.id,
+                        title: check.title,
+                        subTitle: check.description,
+                        completionStatus: check.progress === 100
+                            ? (0, common_1.toCompletionStatusType)('complete')
+                            : (0, common_1.toCompletionStatusType)('incomplete'),
+                        isDisabled: auditSummary == null || auditSummary.auditScorePercentage < 75,
+                        isPrevDisabled: false,
+                        isNextDisabled: false,
+                    };
+                case 'account_recon':
+                case 'je_schedules':
+                case 'missing_receipts':
+                case 'flux_analysis':
+                case 'transaction_categorization':
+                    return {
+                        step: check.id,
+                        title: check.title,
+                        subTitle: check.description,
+                        completionStatus: check.progress === 100
+                            ? (0, common_1.toCompletionStatusType)('complete')
+                            : (0, common_1.toCompletionStatusType)('incomplete'),
+                        isDisabled: false,
+                        isPrevDisabled: false,
+                        isNextDisabled: false,
+                    };
+            }
+        });
+        return steps;
+    }
+    return [];
+};
+exports.getAllSteps = getAllSteps;

package/lib/view/expenseAutomationView/selectorTypes/fluxAnalysisViewSelectorTypes.d.ts

@@ -0,0 +1,32 @@
+import { Currency } from '../../../commonStateTypes/amount';
+import { FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { User } from '../../../entity/user/userState';
+import { Vendor } from '../../../entity/vendor/vendorState';
+import { ZeniDate } from '../../../zeniDayJS';
+import { FluxAnalysisReviewStatus, FluxAnalysisViewUIState, FluxBalancesByMonth } from '../types/fluxAnalysisViewState';
+export interface FluxAnalysisOperatingExpenseView {
+    operatingExpenseId: ID;
+    vendor: Vendor;
+    accountBase: AccountBase | undefined;
+    classBase: ClassBase | undefined;
+    reviewedByUser: User | undefined;
+    varianceAmount: number;
+    variancePercentage: number;
+    currency: Currency;
+    anomalyReason: string;
+    status: FluxAnalysisReviewStatus;
+    balancesByMonth?: FluxBalancesByMonth;
+    reviewStatus: FetchStateAndError;
+}
+export interface ExpenseAutomationFluxAnalysisViewSelector {
+    operatingExpensesView: FluxAnalysisOperatingExpenseView[];
+    reviewOperatingExpensesIds: ID[];
+    fetchStatus: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    bulkReviewStatus: FetchStateAndError;
+    uiState: FluxAnalysisViewUIState;
+    lastRefreshSuccessTime?: ZeniDate;
+    isAllSelected: boolean;
+}

package/lib/view/expenseAutomationView/selectorTypes/fluxAnalysisViewSelectorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/expenseAutomationView/selectorTypes/jeSchedulesSelectorTypes.d.ts

@@ -0,0 +1,28 @@
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { CompletionStatusType, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { JEScheduledTransaction } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { JEScheduleTransactionKey } from '../../../entity/jeSchedules/jeSchedulesTypes';
+import { UncategorizedAccounts } from '../../accountList/accountListSelector';
+import { JEScheduledTransactionWithFailedEntries } from '../selectors/jeSchedulesViewSelector';
+import { JEScheduleLocalData, JESchedulesViewUIState } from '../types/jeSchedulesViewState';
+export interface ExpenseAutomationJESchedulesViewSelector extends SelectorView {
+    uiState: JESchedulesViewUIState;
+    draftSchedules: JEScheduledTransaction[];
+    refreshStatus: FetchStateAndError;
+    resolveSchedules: JEScheduledTransactionWithFailedEntries[];
+    completionStatus: CompletionStatusType;
+    jeScheduleLocalDataById: Record<ID, JEScheduleLocalData>;
+    allAccountList: AccountBase[];
+    uncategorizedAccounts: UncategorizedAccounts;
+    accountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    allClassList: ClassBase[];
+    classListNestedAccountHierarchy: NestedClassHierarchyForReport[];
+    allDepreciationAccountList: AccountBase[];
+    allDepreciationAccountListNestedAccountHierarchy: NestedAccountHierarchyForReport[];
+    postStatusById: Record<ID, FetchStateAndError>;
+    ignoreStatusById: Record<JEScheduleTransactionKey, FetchStateAndError>;
+}

package/lib/view/expenseAutomationView/selectorTypes/jeSchedulesSelectorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/expenseAutomationView/selectorTypes/missingReceiptsSelectorTypes.d.ts

@@ -0,0 +1,11 @@
+import { CompletionStatusType, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { SupportedTransaction } from '../../../entity/transaction/transactionState';
+import { MissingReceiptsViewUIState } from '../types/missingReceiptsViewState';
+export interface ExpenseAutomationMissingReceiptsViewSelector extends SelectorView {
+    uiState: MissingReceiptsViewUIState;
+    uploadReceiptStatusById: Record<ID, FetchStateAndError>;
+    refreshStatus: FetchStateAndError;
+    transactions: SupportedTransaction[];
+    completionStatus: CompletionStatusType;
+}

package/lib/view/expenseAutomationView/selectorTypes/missingReceiptsSelectorTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/expenseAutomationView/selectors/fluxAnalysisViewSelector.d.ts

@@ -0,0 +1,3 @@
+import { RootState } from '../../../reducer';
+import { ExpenseAutomationFluxAnalysisViewSelector } from '../selectorTypes/fluxAnalysisViewSelectorTypes';
+export declare function getExpenseAutomationFluxAnalysisView(state: RootState): ExpenseAutomationFluxAnalysisViewSelector;

package/lib/view/expenseAutomationView/selectors/fluxAnalysisViewSelector.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpenseAutomationFluxAnalysisView = void 0;
+const accountSelector_1 = require("../../../entity/account/accountSelector");
+const classSelector_1 = require("../../../entity/class/classSelector");
+const userSelector_1 = require("../../../entity/user/userSelector");
+const vendorSelector_1 = require("../../../entity/vendor/vendorSelector");
+function getExpenseAutomationFluxAnalysisView(state) {
+    const { expenseAutomationFluxAnalysisViewState } = state;
+    const { fetchState, error, refreshStatus, uiState, isAllRowsSelected, reviewOperatingExpensesIds, reviewStatusById, operatingExpenseById, bulkReviewStatus, } = expenseAutomationFluxAnalysisViewState;
+    const fetchStateAndError = {
+        fetchState,
+        error,
+    };
+    const operatingExpenses = Object.values(operatingExpenseById);
+    const operatingExpensesView = [];
+    operatingExpenses.forEach((operatingExpense) => {
+        const vendor = (0, vendorSelector_1.getVendorByVendorId)(state.vendorState, operatingExpense.vendorId);
+        if (vendor != null) {
+            operatingExpensesView.push({
+                operatingExpenseId: operatingExpense.operatingExpenseId,
+                vendor,
+                accountBase: operatingExpense.accountId != null
+                    ? (0, accountSelector_1.getAccountBase)(state.accountState, operatingExpense.accountId, 'account_list')
+                    : undefined,
+                classBase: operatingExpense.classId != null
+                    ? (0, classSelector_1.getClassById)(state.classState, {
+                        classId: operatingExpense.classId,
+                        reportId: 'class_list',
+                    })
+                    : undefined,
+                reviewedByUser: operatingExpense.userId != null
+                    ? (0, userSelector_1.getUserByUserId)(state.userState, operatingExpense.userId)
+                    : undefined,
+                varianceAmount: operatingExpense.varianceAmount,
+                variancePercentage: operatingExpense.variancePercentage,
+                currency: operatingExpense.currency,
+                anomalyReason: operatingExpense.anomalyReason,
+                status: operatingExpense.status,
+                balancesByMonth: operatingExpense.balancesByMonth,
+                reviewStatus: reviewStatusById[operatingExpense.operatingExpenseId],
+            });
+        }
+    });
+    return {
+        fetchStatus: fetchStateAndError,
+        operatingExpensesView,
+        isAllSelected: isAllRowsSelected,
+        bulkReviewStatus,
+        reviewOperatingExpensesIds,
+        uiState,
+        refreshStatus,
+    };
+}
+exports.getExpenseAutomationFluxAnalysisView = getExpenseAutomationFluxAnalysisView;

package/lib/view/expenseAutomationView/selectors/jeSchedulesViewSelector.d.ts

@@ -0,0 +1,7 @@
+import { RootState } from '../../../reducer';
+import { JEScheduledTransaction, ScheduledJournalEntry } from '../../../entity/jeSchedules/jeSchedulesSelector';
+import { ExpenseAutomationJESchedulesViewSelector } from '../selectorTypes/jeSchedulesSelectorTypes';
+export declare function getExpenseAutomationJESchedulesView(state: RootState): ExpenseAutomationJESchedulesViewSelector;
+export interface JEScheduledTransactionWithFailedEntries extends Omit<JEScheduledTransaction, 'scheduledJournalEntry'> {
+    scheduledJournalEntry: ScheduledJournalEntry;
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpenseAutomationJESchedulesView = void 0;
+const jeSchedulesSelector_1 = require("../../../entity/jeSchedules/jeSchedulesSelector");
+const scheduleDetailLocalDataHelper_1 = require("../../scheduleView/scheduleDetailView/scheduleDetailLocalDataHelper");
+const accountSelector_1 = require("../../../entity/account/accountSelector");
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const scheduleListHelper_1 = require("../../scheduleView/scheduleListView/scheduleListHelper");
+const classListSelector_1 = require("../../classList/classListSelector");
+const lodash_1 = require("lodash");
+const scheduleDetailSelector_1 = require("../../scheduleView/scheduleDetailView/scheduleDetailSelector");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
+function getExpenseAutomationJESchedulesView(state) {
+    const jeScheduledTransaction = [];
+    const failedJeScheduledTransaction = [];
+    const { accountState, accountListState, classState, classListState, expenseAutomationJESchedulesViewState, expenseAutomationViewState, } = state;
+    const { jeScheduleTransactionKeysByPeriod, failedJeScheduleTransactionKeysByPeriod, jeScheduleLocalDataById, postStatusById, ignoreStatusById, uiState, error, fetchState, refreshStatus, } = expenseAutomationJESchedulesViewState;
+    const currentTenant = (0, tenantSelector_1.getCurrentTenant)(state);
+    const { selectedPeriodByTenantId } = expenseAutomationViewState;
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const accountTypes = (0, scheduleListHelper_1.getAccountsTypesForScheduleList)('prepaid_expenses');
+    const uncategorizedAccounts = (0, accountListSelector_1.getUncategorizedAccounts)(accountState, accountListState, accountTypes.accountListKey);
+    const scheduleDetailAccountTypes = (0, scheduleDetailLocalDataHelper_1.getAccountsTypesForScheduleDetails)('prepaid_expenses');
+    const scheduleDetailAccountIds = (0, accountSelector_1.getAccountIdsForTypes)(accountState, scheduleDetailAccountTypes);
+    const allAccountList = (0, accountListSelector_1.getAccountList)(accountState, accountListState, 'schedulesAccountList');
+    const filteredAccounts = allAccountList.accounts.filter((account) => scheduleDetailAccountIds.includes(account.accountId));
+    const depreciationCategoryIds = (0, accountSelector_1.getAccountIdsForTypes)(accountState, ['fixed_assets', 'other_assets'] // This will always be for fixed assets list
+    );
+    const accountLabel = (0, scheduleListHelper_1.getAccountLabelForScheduleType)('fixed_assets');
+    const fixedAssetLabelAccountIds = accountLabel != null
+        ? (0, accountListSelector_1.getAccountIdsForLabel)(accountListState, accountTypes.accountListKey, accountLabel)
+        : [];
+    const filteredDepAccounts = allAccountList.accounts.filter((account) => depreciationCategoryIds.includes(account.accountId) &&
+        !fixedAssetLabelAccountIds.includes(account.accountId));
+    const allClassList = (0, classListSelector_1.getClassList)(classState, classListState);
+    const allClasses = allClassList.classes.map((classData) => {
+        return (0, lodash_1.omit)(classData, ['accountIds', 'key']);
+    });
+    const accountListNestedAccountHierarchy = (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, accountTypes.accountListKey).filter((account) => account.accountId[0] != null &&
+        scheduleDetailAccountIds.includes(account.accountId[0]));
+    const depAccountListNestedAccountHierarchy = (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, accountTypes.accountListKey);
+    const filteredDepAccountListNestedAccountHierarchy = (0, scheduleDetailSelector_1.filterNestedAccountHierarchyById)(depAccountListNestedAccountHierarchy, filteredDepAccounts.map((account) => account.accountId));
+    const classListNestedAccountHierarchy = (0, classListSelector_1.getNestedClassListHierarchy)(classListState);
+    const monthYearPeriodId = selectedPeriod != null ? (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod) : null;
+    const jeScheduleTransactionKeysForSelectedPeriod = monthYearPeriodId != null
+        ? jeScheduleTransactionKeysByPeriod[monthYearPeriodId]
+        : null;
+    const failedJeScheduleTransactionKeysForSelectedPeriod = monthYearPeriodId != null
+        ? failedJeScheduleTransactionKeysByPeriod[monthYearPeriodId]
+        : null;
+    const jeScheduleTransactionKeys = jeScheduleTransactionKeysForSelectedPeriod !== null && jeScheduleTransactionKeysForSelectedPeriod !== void 0 ? jeScheduleTransactionKeysForSelectedPeriod : [];
+    const failedJeScheduleTransactionKeys = failedJeScheduleTransactionKeysForSelectedPeriod !== null && failedJeScheduleTransactionKeysForSelectedPeriod !== void 0 ? failedJeScheduleTransactionKeysForSelectedPeriod : [];
+    jeScheduleTransactionKeys.forEach((jeScheduleKey) => {
+        const jeScheduleDetails = (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleTransactionKey)(jeScheduleKey, state);
+        jeScheduledTransaction.push(jeScheduleDetails);
+    });
+    failedJeScheduleTransactionKeys.forEach((jeScheduleKey) => {
+        const jeScheduleDetails = (0, jeSchedulesSelector_1.getJEScheduledTransactionByJEScheduleTransactionKey)(jeScheduleKey, state);
+        failedJeScheduledTransaction.push(jeScheduleDetails);
+    });
+    const draftSchedules = jeScheduledTransaction.filter((schedule) => schedule.status.code === 'draft');
+    const resolveSchedules = [];
+    failedJeScheduledTransaction.forEach((schedule) => {
+        schedule.scheduledJournalEntry.forEach((journalEntry) => {
+            resolveSchedules.push(Object.assign(Object.assign({}, schedule), { scheduledJournalEntry: journalEntry }));
+        });
+    });
+    return {
+        uncategorizedAccounts,
+        allDepreciationAccountList: filteredDepAccounts,
+        allDepreciationAccountListNestedAccountHierarchy: filteredDepAccountListNestedAccountHierarchy,
+        classListNestedAccountHierarchy,
+        allAccountList: filteredAccounts,
+        accountListNestedAccountHierarchy,
+        allClassList: allClasses,
+        draftSchedules,
+        resolveSchedules: resolveSchedules,
+        postStatusById: postStatusById,
+        ignoreStatusById: ignoreStatusById,
+        fetchState: fetchState,
+        jeScheduleLocalDataById: jeScheduleLocalDataById,
+        uiState: uiState,
+        error: error,
+        refreshStatus,
+        completionStatus: fetchState === 'Completed' &&
+            draftSchedules.length === 0 &&
+            resolveSchedules.length === 0 &&
+            jeScheduleTransactionKeysForSelectedPeriod != null &&
+            failedJeScheduleTransactionKeysForSelectedPeriod != null
+            ? 'complete'
+            : 'incomplete',
+    };
+}
+exports.getExpenseAutomationJESchedulesView = getExpenseAutomationJESchedulesView;

package/lib/view/expenseAutomationView/selectors/missingReceiptsSelector.d.ts

@@ -0,0 +1,3 @@
+import { ExpenseAutomationMissingReceiptsViewSelector } from '../selectorTypes/missingReceiptsSelectorTypes';
+import { RootState } from '../../../reducer';
+export declare function getExpenseAutomationMissingReceiptsView(state: RootState): ExpenseAutomationMissingReceiptsViewSelector;

package/lib/view/expenseAutomationView/selectors/missingReceiptsSelector.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpenseAutomationMissingReceiptsView = void 0;
+const orderBy_1 = __importDefault(require("lodash/orderBy"));
+const transactionSelector_1 = require("../../../entity/transaction/transactionSelector");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
+function getExpenseAutomationMissingReceiptsView(state) {
+    const { expenseAutomationMissingReceiptsViewState, expenseAutomationViewState, transactionState, } = state;
+    const currentTenant = (0, tenantSelector_1.getCurrentTenant)(state);
+    const { selectedPeriodByTenantId } = expenseAutomationViewState;
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    const { uploadReceiptStatusById, fetchState, error, uiState, refreshStatus, transactionIdsBySelectedPeriod, } = expenseAutomationMissingReceiptsViewState;
+    const monthYearPeriodId = selectedPeriod != null ? (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod) : null;
+    const transactionIdsForSelectedPeriod = monthYearPeriodId != null
+        ? transactionIdsBySelectedPeriod[monthYearPeriodId]
+        : null;
+    const transactionIds = transactionIdsForSelectedPeriod !== null && transactionIdsForSelectedPeriod !== void 0 ? transactionIdsForSelectedPeriod : [];
+    const transactions = (0, transactionSelector_1.getSupportedTransactionsByIds)(transactionState, transactionIds);
+    const sortedTransactions = (0, orderBy_1.default)(transactions, (transaction) => {
+        var _a, _b, _c;
+        switch (uiState.sortKey) {
+            case 'date':
+                return transaction.date.valueOf();
+            case 'amount':
+                return transaction.amount.amount;
+            case 'category':
+                return transaction.lines != null &&
+                    transaction.lines.length > 0 &&
+                    ((_a = transaction.lines[0]) === null || _a === void 0 ? void 0 : _a.account) != null
+                    ? transaction.lines[0].account.accountName.toLowerCase()
+                    : null;
+            case 'class':
+                return transaction.lines != null &&
+                    transaction.lines.length > 0 &&
+                    ((_b = transaction.lines[0]) === null || _b === void 0 ? void 0 : _b.class) != null
+                    ? transaction.lines[0].class.className.toLowerCase()
+                    : null;
+            case 'vendor':
+            default:
+                return ((_c = transaction.vendorName) !== null && _c !== void 0 ? _c : transaction.description).toLowerCase();
+        }
+    }, uiState.sortOrder === 'ascending' ? 'asc' : 'desc');
+    return {
+        fetchState,
+        error,
+        uploadReceiptStatusById,
+        uiState,
+        refreshStatus,
+        transactions: sortedTransactions,
+        completionStatus: transactionIdsForSelectedPeriod != null &&
+            fetchState === 'Completed' &&
+            transactionIds.length === 0
+            ? 'complete'
+            : 'incomplete',
+    };
+}
+exports.getExpenseAutomationMissingReceiptsView = getExpenseAutomationMissingReceiptsView;

package/lib/view/expenseAutomationView/types/fluxAnalysisViewState.d.ts

@@ -0,0 +1,53 @@
+import { Currency } from '../../../commonStateTypes/amount';
+import { COABalance } from '../../../commonStateTypes/coaBalance/coaBalance';
+import { FetchedState, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SortOrder } from '../../../commonStateTypes/selectorTypes/sortOrderTypes';
+import { PageToken } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+declare const toFluxAnalysisSortKey: (v: string) => "category" | "class" | "vendors";
+export declare type FluxAnalysisSortKey = ReturnType<typeof toFluxAnalysisSortKey>;
+export declare type FluxAnalysisActionType = 'review' | 'unReview';
+export declare type FluxAnalysisReviewStatus = 'Pending Review' | 'Reviewed';
+export interface FluxBalancesByMonth {
+    month1: COABalance;
+    month2: COABalance;
+}
+export interface FluxAnalysisEntities {
+    operatingExpenses: FluxAnalysisOperatingExpense[];
+}
+export interface FluxAnalysisOperatingExpense {
+    operatingExpenseId: ID;
+    vendorId: ID;
+    accountId: ID | undefined;
+    classId: ID | undefined;
+    userId: ID | undefined;
+    varianceAmount: number;
+    variancePercentage: number;
+    currency: Currency;
+    anomalyReason: string;
+    status: FluxAnalysisReviewStatus;
+    balancesByMonth?: FluxBalancesByMonth;
+}
+export interface FluxAnalysisViewUIState {
+    sortKey: FluxAnalysisSortKey;
+    sortOrder: SortOrder;
+    searchString: string;
+    scrollPosition: {
+        scrollTop: number;
+        scrollLeft?: number;
+    } | undefined;
+    pageToken: PageToken;
+    limit?: number;
+    totalCount: number;
+}
+export interface FluxAnalysisViewState extends FetchedState {
+    fluxAnalysisReportGenerated: boolean;
+    fluxAnalysisEntities: FluxAnalysisEntities;
+    operatingExpenseById: Record<ID, FluxAnalysisOperatingExpense>;
+    reviewStatusById: Record<ID, FetchStateAndError>;
+    bulkReviewStatus: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    uiState: FluxAnalysisViewUIState;
+    reviewOperatingExpensesIds: ID[];
+    isAllRowsSelected: boolean;
+}
+export {};

package/lib/view/expenseAutomationView/types/fluxAnalysisViewState.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stringToUnion_1 = require("../../../commonStateTypes/stringToUnion");
+const FLUX_ANALYSIS_SORT_KEYS = ['vendors', 'category', 'class'];
+const toFluxAnalysisSortKey = (v) => (0, stringToUnion_1.stringToUnion)(v, FLUX_ANALYSIS_SORT_KEYS);