@zeniai/client-epic-state 4.13.18 → 4.13.19

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

@@ -1,23 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearExpenseAutomationTransactionsView = exports.initialState = void 0;
+exports.clearExpenseAutomationTransactionsView = exports.clearExpenseAutomationTransactionsViewPerTabView = exports.updateSelectedCheckboxTransactionIds = exports.fetchTransactionCategorizationView = exports.fetchTransactionCategorizationSuccess = exports.updateTotalCountForTransactionCategorization = exports.setAllItemsToCategoryClassInLocalDataForCategorization = exports.updateSelectedVendorForTransaction = exports.updateStatusForTransactionNotMiscategorizedUpdate = exports.markTransactionAsNotMiscategorized = exports.updateTransactionCategorizationSaveStatus = exports.updateTransactionCategorization = exports.saveTransactionCategorization = exports.fetchTransactionCategorizationFailure = exports.saveTransactionCategorizationLocalData = exports.initializeTransactionCategorizationViewLocalData = exports.updateTransactionCategorizationUIState = exports.fetchTransactionCategorization = exports.initialState = exports.initialTransactionTabViewState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
-exports.initialState = {
+const get_1 = __importDefault(require("lodash/get"));
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const transactionCategorizationLocalDataHelper_1 = require("../helpers/transactionCategorizationLocalDataHelper");
+const vendorTransaction_1 = require("../../../entity/transaction/stateTypes/vendorTransaction");
+exports.initialTransactionTabViewState = {
     saveStatus: {
         fetchState: 'Not-Started',
         error: undefined,
     },
-    updateStatus: {
+    refreshStatus: {
         fetchState: 'Not-Started',
         error: undefined,
     },
-    refreshStatus: {
+    markAsNotMiscategorizedStatus: {
         fetchState: 'Not-Started',
         error: undefined,
     },
     uiState: {
-        sortKey: 'vendor',
-        sortOrder: 'ascending',
+        sortKey: 'date',
+        sortOrder: 'descending',
         searchString: '',
         nodeCollapseState: {},
         scrollPosition: { scrollTop: 0, scrollLeft: undefined },
@@ -25,21 +33,371 @@ exports.initialState = {
         totalCount: 0,
         limit: 10,
     },
-    selectedTab: 'review',
     fetchState: 'Not-Started',
     error: undefined,
     hasValidState() {
         return this.fetchState == 'Completed';
     },
+    transactionReviewLocalDataById: {},
+    transactionIdsBySelectedPeriod: {},
+    selectedCheckBoxTransactionIds: [],
+};
+exports.initialState = {
+    review: Object.assign({}, exports.initialTransactionTabViewState),
+    autoCategorized: Object.assign({}, exports.initialTransactionTabViewState),
 };
 const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
     name: 'expenseAutomationTransactionsView',
     initialState: exports.initialState,
     reducers: {
-        clearExpenseAutomationTransactionsView() {
-            // TODO - Vivek
+        fetchTransactionCategorizationView: {
+            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
+            pageToken, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        selectedTab,
+                        period,
+                        searchString,
+                        keepExistingListItems,
+                        pageToken,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+            reducer() {
+                // do nothing
+            },
+        },
+        fetchTransactionCategorization: {
+            reducer(draft, action) {
+                var _a, _b;
+                const { refreshViewInBackground } = action.payload;
+                const selectedTab = action.payload.selectedTab;
+                if (refreshViewInBackground === true) {
+                    draft[selectedTab].refreshStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+                else {
+                    if (action.payload.pageToken == null) {
+                        draft[selectedTab].fetchState = 'In-Progress';
+                        draft[selectedTab].error = undefined;
+                    }
+                }
+                // Note: Need to reset scroll position whenever a new fetch happens, except when fetching through scroll
+                if (action.payload.pageToken == null) {
+                    // Page Token is null in each fetch except when fetching through scroll
+                    draft[selectedTab].uiState.scrollPosition = {
+                        scrollTop: 0,
+                        scrollLeft: undefined,
+                    };
+                }
+                draft[selectedTab].selectedCheckBoxTransactionIds = [];
+                draft[selectedTab].uiState.pageToken = (_a = action.payload.pageToken) !== null && _a !== void 0 ? _a : null;
+                draft[selectedTab].uiState.searchString =
+                    (_b = action.payload.searchString) !== null && _b !== void 0 ? _b : '';
+                draft[selectedTab].error = undefined;
+            },
+            prepare(selectedTab, period, cacheOverride = false, keepExistingListItems = false, searchString, // when this is defined the output should go to search result IDs
+            pageToken, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        selectedTab,
+                        period,
+                        searchString,
+                        keepExistingListItems,
+                        pageToken,
+                        cacheOverride,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+        },
+        initializeTransactionCategorizationViewLocalData: {
+            prepare(selectedTab, transactionIds, selectedPeriod, keepExistingListItems = false, pageToken, totalCount, refreshViewInBackground = false) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionIds,
+                        selectedPeriod,
+                        keepExistingListItems,
+                        pageToken,
+                        totalCount,
+                        refreshViewInBackground,
+                    },
+                };
+            },
+            reducer() {
+                // do nothing
+            },
+        },
+        saveTransactionCategorizationLocalData(draft, action) {
+            const { keepExistingListItems, transactionIds, transactionLocalData, selectedPeriod, selectedTab, pageToken, totalCount, } = action.payload;
+            if (keepExistingListItems === false) {
+                draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIds;
+            }
+            else {
+                const previousData = draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
+                if (previousData == null) {
+                    draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIds;
+                }
+                else {
+                    draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [...previousData, ...transactionIds];
+                }
+            }
+            draft[selectedTab].transactionReviewLocalDataById = Object.assign(Object.assign({}, draft[selectedTab].transactionReviewLocalDataById), transactionLocalData);
+            draft[selectedTab].selectedCheckBoxTransactionIds = [];
+            if (action.payload.refreshViewInBackground === true) {
+                draft[selectedTab].refreshStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else {
+                draft[selectedTab].fetchState = 'Completed';
+                draft[selectedTab].error = undefined;
+            }
+            draft[selectedTab].uiState = Object.assign(Object.assign({}, draft[selectedTab].uiState), { pageToken: pageToken !== null && pageToken !== void 0 ? pageToken : null, totalCount });
+        },
+        updateTransactionCategorizationUIState(draft, action) {
+            const selectedTab = action.payload.selectedTab;
+            const uiState = action.payload.uiState;
+            if (uiState.sortKey != null) {
+                draft[selectedTab].uiState.sortKey = uiState.sortKey;
+            }
+            if (uiState.sortOrder != null) {
+                draft[selectedTab].uiState.sortOrder = uiState.sortOrder;
+            }
+            if (uiState.searchString != null) {
+                draft[selectedTab].uiState.searchString = uiState.searchString;
+            }
+            if (uiState.scrollPosition != null) {
+                draft[selectedTab].uiState.scrollPosition = uiState.scrollPosition;
+            }
+            if (uiState.pageToken != null) {
+                draft[selectedTab].uiState.pageToken = uiState.pageToken;
+            }
+            if (uiState.totalCount != null) {
+                draft[selectedTab].uiState.totalCount = uiState.totalCount;
+            }
+        },
+        saveTransactionCategorization: {
+            prepare(selectedTab, transactionIds) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionIds,
+                    },
+                };
+            },
+            reducer() {
+                // do nothing
+            },
+        },
+        updateTransactionCategorization: {
+            reducer(draft, action) {
+                const selectedTab = action.payload.selectedTab;
+                draft[selectedTab].saveStatus = {
+                    error: undefined,
+                    fetchState: 'In-Progress',
+                };
+            },
+            prepare(selectedTab, transactionIds, transactionSaveUpdates) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionIds,
+                        transactionSaveUpdates,
+                    },
+                };
+            },
+        },
+        setAllItemsToCategoryClassInLocalDataForCategorization: {
+            reducer(draft, action) {
+                const { vendorId, selectedAccount, selectedClassBase, transactions, transactionId, lineId, selectedTab, } = action.payload;
+                const transactionLocalData = (0, get_1.default)(draft[selectedTab].transactionReviewLocalDataById, transactionId, undefined);
+                if (transactionLocalData != null) {
+                    const newTransactionLocalData = Object.assign(Object.assign({}, transactionLocalData.transactionReviewLocalData), { lineItemById: Object.assign(Object.assign({}, transactionLocalData.transactionReviewLocalData.lineItemById), { [lineId]: Object.assign(Object.assign({}, transactionLocalData.transactionReviewLocalData.lineItemById[lineId]), { account: selectedAccount, class: selectedClassBase }) }) });
+                    draft[selectedTab].transactionReviewLocalDataById[transactionId] = {
+                        transactionReviewLocalData: newTransactionLocalData,
+                        transactionId,
+                    };
+                }
+                if (vendorId != null) {
+                    transactions.forEach((transaction) => {
+                        const transactionLocalData = (0, get_1.default)(draft[selectedTab].transactionReviewLocalDataById, transaction.id, undefined);
+                        if (transactionLocalData != null) {
+                            draft[selectedTab].transactionReviewLocalDataById[transaction.id] = {
+                                transactionId: transaction.id,
+                                transactionReviewLocalData: (0, transactionCategorizationLocalDataHelper_1.toSetAllLineItemsToCategoryClass)(draft[selectedTab], transaction, transactionId, lineId, transactionLocalData.transactionReviewLocalData, vendorId, selectedAccount, selectedClassBase),
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(selectedTab, transactionId, lineId, transactions, vendorId, selectedAccount, selectedClassBase, lineEntity, recommendations) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionId,
+                        lineId,
+                        transactions,
+                        vendorId,
+                        lineEntity,
+                        selectedAccount,
+                        selectedClassBase,
+                        recommendations,
+                    },
+                };
+            },
+        },
+        fetchTransactionCategorizationSuccess(draft, action) {
+            const { selectedTab } = action.payload;
+            if (action.payload.refreshViewInBackground === true) {
+                draft[selectedTab].refreshStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else {
+                draft[selectedTab].fetchState = 'Completed';
+                draft[selectedTab].error = undefined;
+            }
+        },
+        fetchTransactionCategorizationFailure(draft, action) {
+            const { selectedTab, selectedPeriod } = action.payload;
+            draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+            draft[selectedTab].fetchState = 'Error';
+            draft[selectedTab].error = action.payload.status;
+        },
+        updateSelectedVendorForTransaction(draft, action) {
+            const { transactionId, lineId, updatedVendor, selectedTransaction, selectedTab, } = action.payload;
+            const transactionLocalData = (0, get_1.default)(draft[selectedTab].transactionReviewLocalDataById, transactionId, undefined);
+            if (transactionLocalData != null) {
+                const newTransactionLocalData = Object.assign({}, transactionLocalData.transactionReviewLocalData);
+                if (!(0, vendorTransaction_1.isVendorTransaction)(selectedTransaction) &&
+                    updatedVendor != null) {
+                    newTransactionLocalData.lineItemById[lineId] = Object.assign(Object.assign({}, transactionLocalData.transactionReviewLocalData.lineItemById[lineId]), { vendor: {
+                            id: updatedVendor.id,
+                            name: updatedVendor.name,
+                            logo: updatedVendor.logo,
+                        } });
+                }
+                else {
+                    newTransactionLocalData.vendorUpdates =
+                        updatedVendor != null && updatedVendor.id != null
+                            ? {
+                                id: updatedVendor.id,
+                                name: updatedVendor.name,
+                                qboId: updatedVendor.id,
+                            }
+                            : undefined;
+                    newTransactionLocalData.vendor =
+                        updatedVendor != null && updatedVendor.id != null
+                            ? {
+                                id: updatedVendor.id,
+                                name: updatedVendor.name,
+                                logo: updatedVendor.logo,
+                            }
+                            : undefined;
+                }
+                draft[selectedTab].transactionReviewLocalDataById[transactionId] = {
+                    transactionReviewLocalData: newTransactionLocalData,
+                    transactionId,
+                };
+                const selectedCheckBoxTransactionIds = draft[selectedTab].selectedCheckBoxTransactionIds;
+                if (newTransactionLocalData.vendor != null &&
+                    newTransactionLocalData.vendor.id != null &&
+                    selectedCheckBoxTransactionIds.length <= transactionCategorizationLocalDataHelper_1.MAX_SELECTION_LIMIT &&
+                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
+                    draft[selectedTab].selectedCheckBoxTransactionIds = [
+                        ...selectedCheckBoxTransactionIds,
+                        transactionId,
+                    ];
+                }
+            }
+        },
+        updateTransactionCategorizationSaveStatus: {
+            reducer(draft, action) {
+                const selectedTab = action.payload.selectedTab;
+                draft[selectedTab].saveStatus = {
+                    fetchState: action.payload.fetchState,
+                    error: action.payload.error,
+                };
+            },
+            prepare(selectedTab, fetchState, error) {
+                return {
+                    payload: {
+                        selectedTab,
+                        fetchState,
+                        error,
+                    },
+                };
+            },
+        },
+        markTransactionAsNotMiscategorized: {
+            reducer(draft, action) {
+                const selectedTab = action.payload.selectedTab;
+                draft[selectedTab].markAsNotMiscategorizedStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(selectedTab, transactionsInReview) {
+                return {
+                    payload: {
+                        selectedTab,
+                        transactionsInReview,
+                    },
+                };
+            },
+        },
+        updateStatusForTransactionNotMiscategorizedUpdate: {
+            reducer(draft, action) {
+                const { selectedTab, selectedPeriod, transactionIds } = action.payload;
+                if (action.payload.fetchState === 'Completed') {
+                    draft[selectedTab].selectedCheckBoxTransactionIds = [];
+                    const transactionIdsBySelectedPeriod = draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)];
+                    if (transactionIdsBySelectedPeriod != null) {
+                        draft[selectedTab].transactionIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = transactionIdsBySelectedPeriod.filter((id) => !transactionIds.includes(id));
+                    }
+                }
+                draft[selectedTab].markAsNotMiscategorizedStatus = {
+                    fetchState: action.payload.fetchState,
+                    error: action.payload.error,
+                };
+            },
+            prepare(selectedTab, transactionIds, selectedPeriod, fetchState, error) {
+                return {
+                    payload: {
+                        selectedPeriod,
+                        transactionIds,
+                        selectedTab,
+                        fetchState,
+                        error,
+                    },
+                };
+            },
+        },
+        updateTotalCountForTransactionCategorization(draft, action) {
+            const selectedTab = action.payload.selectedTab;
+            draft[selectedTab].uiState.totalCount = action.payload.totalCount;
+        },
+        updateSelectedCheckboxTransactionIds(draft, action) {
+            const selectedTab = action.payload.selectedTab;
+            const transactionIds = action.payload.transactionIds;
+            draft[selectedTab].selectedCheckBoxTransactionIds = [...transactionIds];
+        },
+        clearExpenseAutomationTransactionsViewPerTabView(draft, action) {
+            const selectedTab = action.payload;
+            draft[selectedTab] = Object.assign({}, exports.initialTransactionTabViewState);
+        },
+        clearExpenseAutomationTransactionsView(draft) {
+            Object.assign(draft, exports.initialState);
         },
     },
 });
-exports.clearExpenseAutomationTransactionsView = expenseAutomationTransactionsView.actions.clearExpenseAutomationTransactionsView;
+_a = expenseAutomationTransactionsView.actions, exports.fetchTransactionCategorization = _a.fetchTransactionCategorization, exports.updateTransactionCategorizationUIState = _a.updateTransactionCategorizationUIState, exports.initializeTransactionCategorizationViewLocalData = _a.initializeTransactionCategorizationViewLocalData, exports.saveTransactionCategorizationLocalData = _a.saveTransactionCategorizationLocalData, exports.fetchTransactionCategorizationFailure = _a.fetchTransactionCategorizationFailure, exports.saveTransactionCategorization = _a.saveTransactionCategorization, exports.updateTransactionCategorization = _a.updateTransactionCategorization, exports.updateTransactionCategorizationSaveStatus = _a.updateTransactionCategorizationSaveStatus, exports.markTransactionAsNotMiscategorized = _a.markTransactionAsNotMiscategorized, exports.updateStatusForTransactionNotMiscategorizedUpdate = _a.updateStatusForTransactionNotMiscategorizedUpdate, exports.updateSelectedVendorForTransaction = _a.updateSelectedVendorForTransaction, exports.setAllItemsToCategoryClassInLocalDataForCategorization = _a.setAllItemsToCategoryClassInLocalDataForCategorization, exports.updateTotalCountForTransactionCategorization = _a.updateTotalCountForTransactionCategorization, exports.fetchTransactionCategorizationSuccess = _a.fetchTransactionCategorizationSuccess, exports.fetchTransactionCategorizationView = _a.fetchTransactionCategorizationView, exports.updateSelectedCheckboxTransactionIds = _a.updateSelectedCheckboxTransactionIds, exports.clearExpenseAutomationTransactionsViewPerTabView = _a.clearExpenseAutomationTransactionsViewPerTabView, exports.clearExpenseAutomationTransactionsView = _a.clearExpenseAutomationTransactionsView;
 exports.default = expenseAutomationTransactionsView.reducer;

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

@@ -8,6 +8,8 @@ import { ExpenseAutomationViewType } from '../expenseAutomationViewState';
 import { ExpenseAutomationJESchedulesViewSelector } from './jeSchedulesSelectorTypes';
 import { ExpenseAutomationFluxAnalysisViewSelector } from './fluxAnalysisViewSelectorTypes';
 import { ExpenseAutomationMissingReceiptsViewSelector } from './missingReceiptsSelectorTypes';
+import { ExpenseAutomationTransactionViewSelector } from './transactionsViewSelectorTypes';
+import { TransactionsTab } from '../types/transactionsViewState';
 export interface ExpenseAutomationStepDetails {
     step: ExpenseAutomationViewType;
     title: string;
@@ -20,8 +22,10 @@ export interface ExpenseAutomationStepDetails {
 export declare const getAllSteps: (monthEndCloseChecksState: MonthEndCloseChecksState, monthYearId: MonthYearPeriodId, tenantId: ID, auditSummary?: MonthEndAuditSummary | undefined) => ExpenseAutomationStepDetails[];
 export interface ExpenseAutomationViewSelector extends SelectorView {
     currentSelectedView: ExpenseAutomationViewType;
+    selectedTransactionCategorizationTab: TransactionsTab;
     selectedPeriod: MonthYearPeriod;
     monthEndCloseChecksView: MonthEndCloseChecksView;
+    transactionView: ExpenseAutomationTransactionViewSelector;
     jeSchedules: ExpenseAutomationJESchedulesViewSelector;
     missingReceipts: ExpenseAutomationMissingReceiptsViewSelector;
     fluxAnalysis: ExpenseAutomationFluxAnalysisViewSelector;

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

@@ -0,0 +1,29 @@
+import { NestedAccountHierarchyForReport } from '../../../commonStateTypes/accountView/nestedAccountID';
+import { NestedClassHierarchyForReport } from '../../../commonStateTypes/classesView/nestedClassID';
+import { ID, FetchStateAndError, CompletionStatusType } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { AccountBase } from '../../../entity/account/accountState';
+import { ClassBase } from '../../../entity/class/classState';
+import { SupportedTransaction } from '../../../entity/transaction/transactionState';
+import { UncategorizedAccounts } from '../../accountList/accountListSelector';
+import { TransactionReviewLocalData, TransactionsTab, TransactionsViewUIState } from '../types/transactionsViewState';
+export interface TransactionReviewLocalDataSelectorView {
+    transactionId: ID;
+    transactionReviewLocalData: TransactionReviewLocalData;
+}
+export interface ExpenseAutomationTransactionViewSelector extends SelectorView {
+    uiState: TransactionsViewUIState;
+    uncategorizedAccounts: UncategorizedAccounts;
+    transactions: SupportedTransaction[];
+    accountList: AccountBase[];
+    accountsHierarchyList: NestedAccountHierarchyForReport[];
+    totalCountByTab: Record<TransactionsTab, number>;
+    classList: ClassBase[];
+    classHierarchyList: NestedClassHierarchyForReport[];
+    selectedCheckBoxTransactionIds: ID[];
+    transactionLocalData: TransactionReviewLocalDataSelectorView[];
+    markAsNotMiscategorizedStatus: FetchStateAndError;
+    refreshStatus: FetchStateAndError;
+    saveStatus: FetchStateAndError;
+    completionStatus: CompletionStatusType;
+}

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

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

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

@@ -0,0 +1,4 @@
+import { ExpenseAutomationTransactionViewSelector } from '../selectorTypes/transactionsViewSelectorTypes';
+import { RootState } from '../../../reducer';
+import { TransactionsTab } from '../types/transactionsViewState';
+export declare function getExpenseAutomationTransactionView(state: RootState, selectedTab: TransactionsTab): ExpenseAutomationTransactionViewSelector;

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

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpenseAutomationTransactionView = void 0;
+const omit_1 = __importDefault(require("lodash/omit"));
+const accountListSelector_1 = require("../../accountList/accountListSelector");
+const classListSelector_1 = require("../../classList/classListSelector");
+const transactionSelector_1 = require("../../../entity/transaction/transactionSelector");
+const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
+const tenantSelector_1 = require("../../../entity/tenant/tenantSelector");
+const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
+function getExpenseAutomationTransactionView(state, selectedTab) {
+    const { accountState, classState, classListState, accountListState, expenseAutomationTransactionsViewState, expenseAutomationViewState, transactionState, } = state;
+    const { uiState, refreshStatus, saveStatus, markAsNotMiscategorizedStatus, transactionIdsBySelectedPeriod, transactionReviewLocalDataById, selectedCheckBoxTransactionIds, } = expenseAutomationTransactionsViewState[selectedTab];
+    const uncategorizedIncomeExpense = (0, accountListSelector_1.getUncategorizedAccounts)(accountState, accountListState, 'accountList');
+    const accountList = (0, accountListSelector_1.getAccountList)(accountState, accountListState, 'accountList');
+    const classList = (0, classListSelector_1.getClassList)(classState, classListState);
+    const allClasses = classList.classes.map((classData) => {
+        return (0, omit_1.default)(classData, ['accountIds', 'key']);
+    });
+    const accountsHierarchyList = (0, accountListSelector_1.getNestedAccountListHierarchy)(accountListState, 'accountList');
+    const classHierarchyList = (0, classListSelector_1.getNestedClassListHierarchy)(classListState);
+    const currentTenant = (0, tenantSelector_1.getCurrentTenant)(state);
+    const { selectedPeriodByTenantId } = expenseAutomationViewState;
+    const selectedPeriod = selectedPeriodByTenantId[currentTenant.tenantId];
+    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 transactionLocalData = transactionIds
+        .map((transactionId) => {
+        const transactionData = transactionReviewLocalDataById[transactionId];
+        if (transactionData != null) {
+            return {
+                transactionId,
+                transactionReviewLocalData: transactionData.transactionReviewLocalData,
+            };
+        }
+        return null;
+    })
+        .filter((transaction) => transaction != null);
+    const transactions = (0, transactionSelector_1.getSupportedTransactionsByIds)(transactionState, transactionIds);
+    let fetchStatus = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    fetchStatus = (0, reduceFetchState_1.reduceAllFetchState)([
+        accountList,
+        classList,
+        expenseAutomationTransactionsViewState[selectedTab],
+    ]);
+    const totalCountByTab = {
+        review: expenseAutomationTransactionsViewState['review'].uiState.totalCount,
+        autoCategorized: expenseAutomationTransactionsViewState['autoCategorized'].uiState
+            .totalCount,
+    };
+    return {
+        version: 0,
+        fetchState: fetchStatus.fetchState,
+        error: fetchStatus.error,
+        transactions,
+        selectedCheckBoxTransactionIds,
+        uncategorizedAccounts: uncategorizedIncomeExpense,
+        transactionIdsBySelectedPeriod,
+        accountList: accountList.accounts,
+        classList: allClasses,
+        accountsHierarchyList,
+        classHierarchyList,
+        transactionLocalData,
+        uiState,
+        refreshStatus,
+        saveStatus,
+        markAsNotMiscategorizedStatus,
+        completionStatus: transactionIdsForSelectedPeriod != null &&
+            fetchStatus.fetchState === 'Completed' &&
+            transactionIds.length === 0
+            ? 'complete'
+            : 'incomplete',
+        totalCountByTab,
+    };
+}
+exports.getExpenseAutomationTransactionView = getExpenseAutomationTransactionView;