@zeniai/client-epic-state 4.16.3 → 4.16.4

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

@@ -1,55 +1,39 @@
 "use strict";
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateSelectedSectionIdsForReview = exports.updateFluxAnalysisViewPageMetaData = exports.updateFluxAnalysisViewUIState = exports.reviewFluxAnalysisViewFailure = exports.reviewFluxAnalysisViewSuccess = exports.reviewFluxAnalysisView = exports.updateOperatingExpensesIdsForReview = exports.clearExpenseAutomationFluxAnalysisView = exports.fetchFluxAnalysisViewFailure = exports.fetchFluxAnalysisViewSuccess = exports.fetchFluxAnalysisView = exports.initialState = void 0;
+exports.updateFluxAnalysisViewPageMetaData = exports.updateFluxAnalysisViewUIState = exports.reviewFluxAnalysisViewFailure = exports.reviewFluxAnalysisViewSuccess = exports.reviewFluxAnalysisView = exports.updateOperatingExpensesIdsForReview = exports.clearExpenseAutomationFluxAnalysisView = exports.fetchFluxAnalysisViewFailure = exports.fetchFluxAnalysisViewSuccess = exports.fetchFluxAnalysisView = exports.initialState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
 const timePeriod_1 = require("../../../commonStateTypes/timePeriod");
-const vendorState_1 = require("../../../entity/vendor/vendorState");
 const helpers_1 = require("../helpers/helpers");
 exports.initialState = {
+    reviewStatusById: {},
+    operatingExpenseIdsBySelectedPeriod: {},
     fluxAnalysisEntities: { operatingExpenses: [] },
     uiState: {
         scrollPosition: { scrollTop: 0, scrollLeft: undefined },
+        pageToken: null,
+        hasMore: true,
+        totalCount: 0,
+        limit: 10,
         sortKey: 'vendor',
         searchString: '',
         sortOrder: 'ascending',
-        paginationInfoByGroup: {
-            generalExpense: {
-                pageToken: null,
-                hasMore: true,
-                totalCount: 0,
-                limit: 10,
-            },
-            reimbursement: {
-                pageToken: null,
-                hasMore: true,
-                totalCount: 0,
-                limit: 10,
-            },
-        },
-        collapsableStatus: {
-            generalExpense: true,
-            reimbursement: true,
-        },
-    },
-    fetchState: 'Not-Started',
-    error: undefined,
-    currency: vendorState_1.defaultVendorCurrency,
-    totalBalancesAndVariance: undefined,
-    hasValidState() {
-        return this.fetchState == 'Completed';
     },
     refreshStatus: {
         fetchState: 'Not-Started',
         error: undefined,
     },
+    fetchState: 'Not-Started',
     bulkReviewStatus: {
         fetchState: 'Not-Started',
         error: undefined,
     },
-    groupsBySelectedPeriod: {},
-    reviewOperatingExpenseIdsByPeriod: {},
-    selectedSectionIdsByPeriod: {},
+    error: undefined,
+    fluxAnalysisReportGenerated: false,
+    reviewOperatingExpensesIds: [],
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
 };
 const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
     name: 'expenseAutomationFluxAnalysisView',
@@ -57,45 +41,27 @@ const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
     reducers: {
         fetchFluxAnalysisView: {
             reducer(draft, action) {
-                const { refreshViewInBackground, monthAndYear, resetListItems, fetchReimbursement, } = action.payload;
-                const periodId = (0, timePeriod_1.toMonthYearPeriodId)(monthAndYear);
+                const { refreshViewInBackground, monthAndYear, resetListItems } = action.payload;
                 if (refreshViewInBackground) {
                     draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
                 }
                 else {
                     draft.fetchState = 'In-Progress';
-                    const group = draft.groupsBySelectedPeriod[periodId];
-                    // Initialize group structure if it's the first fetch
-                    if (group == null) {
-                        draft.groupsBySelectedPeriod[periodId] = getInProgressGroup();
-                    }
-                    else {
-                        // Update fetch status based on fetchReimbursement
-                        const statusField = fetchReimbursement
-                            ? 'reimbursement'
-                            : 'generalExpense';
-                        group[statusField].fetchStatus = {
-                            fetchState: 'In-Progress',
-                            error: undefined,
-                        };
-                    }
-                    // Reset list if necessary
-                    if (resetListItems === true) {
-                        const statusField = fetchReimbursement
-                            ? 'reimbursement'
-                            : 'generalExpense';
-                        draft.groupsBySelectedPeriod[periodId][statusField].operatingExpenseIds = [];
-                    }
+                    draft.error = undefined;
+                }
+                // Reset list when we change the sort order and fetch list again
+                if (resetListItems === true) {
+                    draft.operatingExpenseIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(monthAndYear)] = [];
+                    draft.reviewOperatingExpensesIds = [];
                 }
             },
-            prepare(monthAndYear, cacheOverride, refreshViewInBackground, pageToken, fetchReimbursement = false, keepExistingListItems, resetListItems) {
+            prepare(monthAndYear, cacheOverride, refreshViewInBackground, pageToken, keepExistingListItems, resetListItems) {
                 return {
                     payload: {
                         monthAndYear,
                         refreshViewInBackground,
                         cacheOverride,
                         pageToken,
-                        fetchReimbursement,
                         keepExistingListItems,
                         resetListItems,
                     },
@@ -103,79 +69,72 @@ const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
             },
         },
         fetchFluxAnalysisViewSuccess(draft, action) {
-            const { expensesPayload, selectedPeriod, keepExistingListItems, fetchReimbursement, currency, totalsPayload, } = action.payload;
-            const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-            const group = draft.groupsBySelectedPeriod[periodId];
-            const groupToBeFetched = fetchReimbursement
-                ? group.reimbursement
-                : group.generalExpense;
+            const { expensesPayload, selectedPeriod, keepExistingListItems, currency } = action.payload;
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Completed';
+                draft.error = undefined;
+            }
+            else {
+                draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            }
+            draft.reviewStatusById = Object.assign(Object.assign({}, draft.reviewStatusById), toReviewStatusById(expensesPayload));
             const fluxOpExEntityIds = expensesPayload.map((expense) => expense.flux_analysis_entity_id);
-            // Handle fetch completion
-            handleFetchCompletion(draft, selectedPeriod, fetchReimbursement, groupToBeFetched);
-            draft.fetchState = 'Completed';
-            // Update flux analysis entities
-            const allFluxAnalysisEntities = updateFluxAnalysisEntities(draft.fluxAnalysisEntities, expensesPayload, currency);
-            // Update operating expense ids based on the "keepExistingListItems" flag
-            updateOperatingExpenseIds(draft, selectedPeriod, groupToBeFetched, fluxOpExEntityIds, fetchReimbursement, keepExistingListItems);
-            // Update total balances and variance if available
-            if (totalsPayload != null) {
-                updateTotals(draft, selectedPeriod, totalsPayload, currency);
+            if (keepExistingListItems === true) {
+                const allFluxAnalysisEntities = {
+                    operatingExpenses: [
+                        ...draft.fluxAnalysisEntities.operatingExpenses,
+                        ...toFluxAnalysisOperatingExpenses(expensesPayload, currency),
+                    ],
+                };
+                const allOperatingExpenseIdsBySelectedPeriod = [
+                    ...draft.operatingExpenseIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)],
+                    ...fluxOpExEntityIds,
+                ];
+                draft.fluxAnalysisEntities = allFluxAnalysisEntities;
+                draft.operatingExpenseIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = allOperatingExpenseIdsBySelectedPeriod;
+            }
+            else {
+                draft.operatingExpenseIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = fluxOpExEntityIds;
+                draft.fluxAnalysisEntities = {
+                    operatingExpenses: [
+                        ...toFluxAnalysisOperatingExpenses(expensesPayload, currency),
+                        ...draft.fluxAnalysisEntities.operatingExpenses,
+                    ],
+                };
             }
-            // Set currency
-            draft.currency = {
-                currencyCode: currency.currency_code,
-                currencySymbol: currency.currency_symbol,
-            };
-            // Reset review operating expenses ids for the period
-            draft.reviewOperatingExpenseIdsByPeriod[periodId] = [];
-            // Final update of flux analysis entities
-            draft.fluxAnalysisEntities = allFluxAnalysisEntities;
         },
         updateFluxAnalysisViewPageMetaData(draft, action) {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            draft.uiState = Object.assign(Object.assign({}, draft.uiState), { paginationInfoByGroup: {
-                    generalExpense: action.payload.fetchReimbursement === true
-                        ? draft.uiState.paginationInfoByGroup.generalExpense
-                        : Object.assign(Object.assign({}, draft.uiState.paginationInfoByGroup.generalExpense), { pageToken: (_b = (_a = action.payload.pageMetaData) === null || _a === void 0 ? void 0 : _a.next_page_token) !== null && _b !== void 0 ? _b : null, hasMore: (_d = (_c = action.payload.pageMetaData) === null || _c === void 0 ? void 0 : _c.is_more_data_to_load) !== null && _d !== void 0 ? _d : true }),
-                    reimbursement: action.payload.fetchReimbursement === false
-                        ? draft.uiState.paginationInfoByGroup.reimbursement
-                        : Object.assign(Object.assign({}, draft.uiState.paginationInfoByGroup.reimbursement), { pageToken: (_f = (_e = action.payload.pageMetaData) === null || _e === void 0 ? void 0 : _e.next_page_token) !== null && _f !== void 0 ? _f : null, hasMore: (_h = (_g = action.payload.pageMetaData) === null || _g === void 0 ? void 0 : _g.is_more_data_to_load) !== null && _h !== void 0 ? _h : true }),
-                } });
+            var _a, _b, _c, _d;
+            draft.uiState = Object.assign(Object.assign({}, draft.uiState), { pageToken: (_b = (_a = action.payload.pageMetaData) === null || _a === void 0 ? void 0 : _a.next_page_token) !== null && _b !== void 0 ? _b : null, hasMore: (_d = (_c = action.payload.pageMetaData) === null || _c === void 0 ? void 0 : _c.is_more_data_to_load) !== null && _d !== void 0 ? _d : true });
         },
         fetchFluxAnalysisViewFailure(draft, action) {
-            var _a, _b;
-            const { status, fetchReimbursement, selectedPeriod } = action.payload;
-            const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-            if (fetchReimbursement) {
-                updateFetchFailureStatus(draft, selectedPeriod, 'reimbursement', status);
+            const { status, selectedPeriod } = action.payload;
+            draft.operatingExpenseIdsBySelectedPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = [];
+            if (draft.fetchState === 'In-Progress') {
+                draft.fetchState = 'Error';
+                draft.error = status;
             }
             else {
-                const generalExpenseStatus = (_b = (_a = draft.groupsBySelectedPeriod[periodId]) === null || _a === void 0 ? void 0 : _a.generalExpense) === null || _b === void 0 ? void 0 : _b.fetchStatus.fetchState;
-                if (generalExpenseStatus === 'In-Progress') {
-                    updateFetchFailureStatus(draft, selectedPeriod, 'generalExpense', status);
-                }
-                else {
-                    draft.refreshStatus = { fetchState: 'Error', error: status };
-                }
+                draft.refreshStatus = { fetchState: 'Error', error: status };
             }
-            draft.fetchState = 'Error';
-            draft.error = status;
-        },
-        // This action updates the sections ids whenever a section is bulk selected
-        updateSelectedSectionIdsForReview(draft, action) {
-            const { sectionId, selectedPeriod } = action.payload;
-            draft.selectedSectionIdsByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] =
-                sectionId;
         },
         updateOperatingExpensesIdsForReview(draft, action) {
-            const { operatingExpenseIds, selectedPeriod } = action.payload;
-            draft.reviewOperatingExpenseIdsByPeriod[(0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod)] = operatingExpenseIds;
+            const { operatingExpenseIds } = action.payload;
+            draft.reviewOperatingExpensesIds = operatingExpenseIds;
         },
         reviewFluxAnalysisView: {
-            reducer(draft) {
-                draft.bulkReviewStatus = {
-                    fetchState: 'In-Progress',
-                };
+            reducer(draft, action) {
+                const { operatingExpenseIds, isBulk } = action.payload;
+                operatingExpenseIds.forEach((id) => {
+                    draft.reviewStatusById[id] = {
+                        fetchState: 'In-Progress',
+                    };
+                });
+                if (isBulk === true) {
+                    draft.bulkReviewStatus = {
+                        fetchState: 'In-Progress',
+                    };
+                }
             },
             prepare(actionType, operatingExpenseIds, selectedPeriod, isBulk) {
                 return {
@@ -184,32 +143,41 @@ const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
             },
         },
         reviewFluxAnalysisViewSuccess(draft, action) {
-            const { expensesPayload, currency, selectedPeriod } = action.payload;
-            const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-            // Create a map of flux entity IDs to be removed for efficiency
-            const fluxEntitiesToRemove = new Set(expensesPayload.map((opExPayload) => opExPayload.flux_analysis_entity_id));
-            // Generate updated flux entities
-            const updatedFluxEntities = [
-                ...draft.fluxAnalysisEntities.operatingExpenses.filter((fluxEntity) => !fluxEntitiesToRemove.has(fluxEntity.fluxAnalysisEntityId)),
-                ...expensesPayload.map((opExPayload) => toFluxAnalysisOperatingExpense(opExPayload, currency)),
-            ];
-            // Update the draft with the new list of operating expenses
+            const { expensesPayload, currency, isBulk } = action.payload;
+            let updatedFluxEntities = draft.fluxAnalysisEntities.operatingExpenses;
+            expensesPayload.forEach((opExPayload) => {
+                draft.reviewStatusById[opExPayload.flux_analysis_entity_id] = {
+                    fetchState: 'Completed',
+                };
+                const fluxEntity = toFluxAnalysisOperatingExpense(opExPayload, currency);
+                updatedFluxEntities = updatedFluxEntities.filter((fluxEntity) => fluxEntity.operatingExpenseId !==
+                    opExPayload.flux_analysis_entity_id);
+                updatedFluxEntities.push(fluxEntity);
+            });
             draft.fluxAnalysisEntities = {
                 operatingExpenses: updatedFluxEntities,
             };
-            // Reset the review state
-            draft.reviewOperatingExpenseIdsByPeriod[periodId] = [];
-            draft.selectedSectionIdsByPeriod[periodId] = [];
-            draft.bulkReviewStatus = {
-                fetchState: 'Completed',
-            };
+            draft.reviewOperatingExpensesIds = [];
+            if (isBulk === true) {
+                draft.bulkReviewStatus = {
+                    fetchState: 'Completed',
+                };
+            }
         },
         reviewFluxAnalysisViewFailure(draft, action) {
-            const { status } = action.payload;
-            draft.bulkReviewStatus = {
-                fetchState: 'Error',
-                error: status,
-            };
+            const { operatingExpenseIds, status, isBulk } = action.payload;
+            operatingExpenseIds.forEach((id) => {
+                if (draft.reviewStatusById[id].fetchState === 'In-Progress') {
+                    draft.reviewStatusById[id].fetchState = 'Error';
+                    draft.reviewStatusById[id].error = status;
+                }
+            });
+            if (isBulk === true) {
+                draft.bulkReviewStatus = {
+                    fetchState: 'Error',
+                    error: status,
+                };
+            }
         },
         updateFluxAnalysisViewUIState(draft, action) {
             if (action.payload.sortKey != null) {
@@ -224,9 +192,6 @@ const expenseAutomationFluxAnalysisView = (0, toolkit_1.createSlice)({
             if (action.payload.scrollPosition != null) {
                 draft.uiState.scrollPosition = action.payload.scrollPosition;
             }
-            if (action.payload.collapsableStatus != null) {
-                draft.uiState.collapsableStatus = action.payload.collapsableStatus;
-            }
         },
         clearExpenseAutomationFluxAnalysisView(draft) {
             Object.assign(draft, exports.initialState);
@@ -243,9 +208,10 @@ const toFluxAnalysisOperatingExpenses = (operatingExpensesPayload, currency) =>
 const toFluxAnalysisOperatingExpense = (operatingExpensePayload, currency) => {
     var _a;
     return {
-        fluxAnalysisEntityId: operatingExpensePayload.flux_analysis_entity_id,
+        operatingExpenseId: operatingExpensePayload.flux_analysis_entity_id,
         vendorId: operatingExpensePayload.vendor_id,
-        vendorAccountsAndClasses: toVendorAccountsAndClasses(operatingExpensePayload.category_and_class_json, currency),
+        accountId: operatingExpensePayload.account_id,
+        classId: operatingExpensePayload.accounting_class_id,
         userId: (_a = operatingExpensePayload.reviewed_by_user_id) !== null && _a !== void 0 ? _a : undefined,
         varianceAmount: operatingExpensePayload.variance_amount,
         variancePercentage: operatingExpensePayload.variance_percentage,
@@ -258,111 +224,15 @@ const toFluxAnalysisOperatingExpense = (operatingExpensePayload, currency) => {
         balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(operatingExpensePayload.month_1, operatingExpensePayload.month_2, currency),
     };
 };
-const toVendorAccountsAndClasses = (accountAndClassJSON, currency) => {
-    return accountAndClassJSON.map((accountAndClass) => {
-        return {
-            varianceAmount: accountAndClass.variance_amount,
-            variancePercentage: accountAndClass.variance_percentage,
-            accountId: accountAndClass.account_id,
-            classId: accountAndClass.accounting_class_id,
-            balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(accountAndClass.month_1, accountAndClass.month_2, currency),
-        };
-    });
-};
-const getInProgressGroup = () => {
-    return {
-        generalExpense: {
-            fetchStatus: {
-                fetchState: 'In-Progress',
-                error: undefined,
-            },
-            operatingExpenseIds: [],
-            total: undefined,
-        },
-        reimbursement: {
-            fetchStatus: { fetchState: 'Not-Started', error: undefined },
-            operatingExpenseIds: [],
-            total: undefined,
-        },
-    };
-};
-// Helper function to handle the fetch completion
-const handleFetchCompletion = (draft, selectedPeriod, fetchReimbursement, groupToBeFetched) => {
-    const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-    if (fetchReimbursement) {
-        draft.groupsBySelectedPeriod[periodId].reimbursement.fetchStatus = {
-            fetchState: 'Completed',
-            error: undefined,
-        };
-    }
-    else if (groupToBeFetched.fetchStatus.fetchState === 'In-Progress') {
-        draft.groupsBySelectedPeriod[periodId].generalExpense.fetchStatus = {
-            fetchState: 'Completed',
+const toReviewStatusById = (operatingExpenses) => {
+    const reviewStatusById = {};
+    operatingExpenses.forEach((operatingExpense) => {
+        reviewStatusById[operatingExpense.flux_analysis_entity_id] = {
+            fetchState: 'Not-Started',
             error: undefined,
         };
-    }
-    else {
-        draft.refreshStatus = { fetchState: 'Completed', error: undefined };
-    }
-};
-// Helper function to update flux analysis entities
-const updateFluxAnalysisEntities = (existingEntities, expensesPayload, currency) => {
-    const incomingExpenses = toFluxAnalysisOperatingExpenses(expensesPayload, currency);
-    // Combine existing and incoming expenses, prioritizing incoming
-    const allExpenses = [
-        ...existingEntities.operatingExpenses,
-        ...incomingExpenses,
-    ];
-    // Use a Map to deduplicate by fluxAnalysisEntityId, keeping the latest (incoming) entry
-    const expensesMap = new Map();
-    allExpenses.forEach((expense) => {
-        expensesMap.set(expense.fluxAnalysisEntityId, expense);
     });
-    return { operatingExpenses: Array.from(expensesMap.values()) };
-};
-// Helper function to update operating expense ids
-const updateOperatingExpenseIds = (draft, selectedPeriod, groupToBeFetched, fluxOpExEntityIds, fetchReimbursement, keepExistingListItems) => {
-    const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-    const updatedOperatingExpenseIds = keepExistingListItems === true
-        ? Array.from(new Set([
-            ...groupToBeFetched.operatingExpenseIds,
-            ...fluxOpExEntityIds,
-        ]))
-        : fluxOpExEntityIds;
-    if (fetchReimbursement) {
-        draft.groupsBySelectedPeriod[periodId].reimbursement.operatingExpenseIds =
-            updatedOperatingExpenseIds;
-    }
-    else {
-        draft.groupsBySelectedPeriod[periodId].generalExpense.operatingExpenseIds =
-            updatedOperatingExpenseIds;
-    }
-};
-// Helper function to update totals
-const updateTotals = (draft, selectedPeriod, totalsPayload, currency) => {
-    const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-    draft.totalBalancesAndVariance = {
-        balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(totalsPayload.total.month_1, totalsPayload.total.month_2, currency),
-        varianceAmount: totalsPayload.total.variance_amount,
-        variancePercentage: totalsPayload.total.variance_percentage,
-    };
-    draft.groupsBySelectedPeriod[periodId].generalExpense.total = {
-        balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(totalsPayload.general_expenses.month_1, totalsPayload.general_expenses.month_2, currency),
-        varianceAmount: totalsPayload.general_expenses.variance_amount,
-        variancePercentage: totalsPayload.general_expenses.variance_percentage,
-    };
-    draft.groupsBySelectedPeriod[periodId].reimbursement.total = {
-        balancesByMonth: (0, helpers_1.toBalancesByMonthFromPayload)(totalsPayload.reimbursement.month_1, totalsPayload.reimbursement.month_2, currency),
-        varianceAmount: totalsPayload.reimbursement.variance_amount,
-        variancePercentage: totalsPayload.reimbursement.variance_percentage,
-    };
-};
-// Helper function to update the fetch failure status for a group
-const updateFetchFailureStatus = (draft, selectedPeriod, groupType, status) => {
-    const periodId = (0, timePeriod_1.toMonthYearPeriodId)(selectedPeriod);
-    const group = draft.groupsBySelectedPeriod[periodId][groupType];
-    group.operatingExpenseIds = [];
-    group.fetchStatus = { fetchState: 'Error', error: status };
+    return reviewStatusById;
 };
-_a = expenseAutomationFluxAnalysisView.actions, exports.fetchFluxAnalysisView = _a.fetchFluxAnalysisView, exports.fetchFluxAnalysisViewSuccess = _a.fetchFluxAnalysisViewSuccess, exports.fetchFluxAnalysisViewFailure = _a.fetchFluxAnalysisViewFailure, exports.clearExpenseAutomationFluxAnalysisView = _a.clearExpenseAutomationFluxAnalysisView, exports.updateOperatingExpensesIdsForReview = _a.updateOperatingExpensesIdsForReview, exports.reviewFluxAnalysisView = _a.reviewFluxAnalysisView, exports.reviewFluxAnalysisViewSuccess = _a.reviewFluxAnalysisViewSuccess, exports.reviewFluxAnalysisViewFailure = _a.reviewFluxAnalysisViewFailure, exports.updateFluxAnalysisViewUIState = _a.updateFluxAnalysisViewUIState, exports.updateFluxAnalysisViewPageMetaData = _a.updateFluxAnalysisViewPageMetaData, exports.updateSelectedSectionIdsForReview = _a.updateSelectedSectionIdsForReview;
+_a = expenseAutomationFluxAnalysisView.actions, exports.fetchFluxAnalysisView = _a.fetchFluxAnalysisView, exports.fetchFluxAnalysisViewSuccess = _a.fetchFluxAnalysisViewSuccess, exports.fetchFluxAnalysisViewFailure = _a.fetchFluxAnalysisViewFailure, exports.clearExpenseAutomationFluxAnalysisView = _a.clearExpenseAutomationFluxAnalysisView, exports.updateOperatingExpensesIdsForReview = _a.updateOperatingExpensesIdsForReview, exports.reviewFluxAnalysisView = _a.reviewFluxAnalysisView, exports.reviewFluxAnalysisViewSuccess = _a.reviewFluxAnalysisViewSuccess, exports.reviewFluxAnalysisViewFailure = _a.reviewFluxAnalysisViewFailure, exports.updateFluxAnalysisViewUIState = _a.updateFluxAnalysisViewUIState, exports.updateFluxAnalysisViewPageMetaData = _a.updateFluxAnalysisViewPageMetaData;
 exports.default = expenseAutomationFluxAnalysisView.reducer;

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

@@ -90,6 +90,14 @@ const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
                         'In-Progress';
                     draft.transactionCategorizationView[selectedTab].error = undefined;
                 }
+                // Note: Need to reset scroll position whenever a new fetch happens, except when fetching through scroll
+                if (pageToken == null) {
+                    // Page Token is null in each fetch except when fetching through scroll
+                    draft.transactionCategorizationView[selectedTab].uiState.scrollPosition = {
+                        scrollTop: 0,
+                        scrollLeft: undefined,
+                    };
+                }
                 draft.transactionCategorizationView[selectedTab].uiState.pageToken =
                     pageToken !== null && pageToken !== void 0 ? pageToken : null;
                 draft.transactionCategorizationView[selectedTab].uiState.searchString =
@@ -338,20 +346,18 @@ const expenseAutomationTransactionsView = (0, toolkit_1.createSlice)({
             },
         },
         fetchTransactionCategorizationSuccess(draft, action) {
-            const { selectedTab, refreshViewInBackground } = action.payload;
-            if (draft.transactionCategorizationView[selectedTab].fetchState ===
-                'In-Progress' ||
-                refreshViewInBackground !== true) {
-                draft.transactionCategorizationView[selectedTab].fetchState =
-                    'Completed';
-                draft.transactionCategorizationView[selectedTab].error = undefined;
-            }
-            else {
+            const { selectedTab } = action.payload;
+            if (action.payload.refreshViewInBackground === true) {
                 draft.transactionCategorizationView[selectedTab].refreshStatus = {
                     fetchState: 'Completed',
                     error: undefined,
                 };
             }
+            else {
+                draft.transactionCategorizationView[selectedTab].fetchState =
+                    'Completed';
+                draft.transactionCategorizationView[selectedTab].error = undefined;
+            }
         },
         fetchTransactionCategorizationFailure(draft, action) {
             const { selectedTab, selectedPeriod } = action.payload;

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

@@ -5,48 +5,28 @@ import { ClassBase } from '../../../entity/class/classState';
 import { User } from '../../../entity/user/userState';
 import { Vendor } from '../../../entity/vendor/vendorState';
 import { ZeniDate } from '../../../zeniDayJS';
-import { BalancesAndVariance, FluxAnalysisReviewStatus, FluxAnalysisViewUIState, FluxBalancesByMonth } from '../types/fluxAnalysisViewState';
-export interface FluxVendorAccountsAndClassesView {
-    varianceAmount: number;
-    variancePercentage: number;
+import { FluxAnalysisReviewStatus, FluxAnalysisViewUIState, FluxBalancesByMonth } from '../types/fluxAnalysisViewState';
+export interface FluxAnalysisOperatingExpenseView {
+    operatingExpenseId: ID;
+    vendor: Vendor;
     accountBase: AccountBase | undefined;
     classBase: ClassBase | undefined;
-    currency: Currency;
-    balancesByMonth?: FluxBalancesByMonth;
-}
-export interface FluxAnalysisOperatingExpenseView extends BalancesAndVariance {
-    fluxAnalysisEntityId: ID;
-    vendorAccountsAndClasses: FluxVendorAccountsAndClassesView[];
-    reviewedByUser: User | undefined;
-    currency: Currency;
-    anomalyReason: string;
-    status: FluxAnalysisReviewStatus;
-}
-export interface FluxAnalysisVendorView extends BalancesAndVariance {
-    fluxAnalysisEntityId: ID;
-    vendor: Vendor;
     reviewedByUser: User | undefined;
+    varianceAmount: number;
+    variancePercentage: number;
     currency: Currency;
     anomalyReason: string;
     status: FluxAnalysisReviewStatus;
-    vendorAccountsAndClasses: FluxVendorAccountsAndClassesView[];
-}
-export interface FluxAnalysisViewSectionReport extends BalancesAndVariance {
-    sectionId: FluxAnalysisSectionType;
-    vendors: FluxAnalysisVendorView[];
-    fetchStatus: FetchStateAndError;
+    balancesByMonth?: FluxBalancesByMonth;
+    reviewStatus: FetchStateAndError;
 }
-export type FluxAnalysisSectionType = 'generalExpense' | 'reimbursement';
 export interface ExpenseAutomationFluxAnalysisViewSelector {
-    sections: Record<FluxAnalysisSectionType, FluxAnalysisViewSectionReport>;
-    totalBalancesAndVariance: BalancesAndVariance | undefined;
+    operatingExpensesView: FluxAnalysisOperatingExpenseView[];
     reviewOperatingExpensesIds: ID[];
-    selectedSectionIds: FluxAnalysisSectionType[];
     fetchStatus: FetchStateAndError;
     refreshStatus: FetchStateAndError;
     bulkReviewStatus: FetchStateAndError;
     uiState: FluxAnalysisViewUIState;
-    currency: Currency;
     lastRefreshSuccessTime?: ZeniDate;
     completionStatus: CompletionStatusType;
 }