@zeniai/client-epic-state 5.1.21 → 5.1.23-betaNB1

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

@@ -2,6 +2,7 @@ import { createSlice } from '@reduxjs/toolkit';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { toReconciliationAccountSource } from '../../../entity/account/accountState';
 import { toBankStatusCodeType } from '../../../entity/accountRecon/accountReconState';
+import { toReconciliationViewSummary, } from '../types/reconciliationViewState';
 // Initial state
 export const initialReconciliationTabsState = {
     balances: {
@@ -67,6 +68,7 @@ export const initialState = {
     refreshStatus: { fetchState: 'Not-Started', error: undefined },
     actionFetchState: initialActionFetchState,
     selectedAccountId: undefined,
+    statementProcessingFailed: false,
     statementUploadChosen: false,
     reconListUIState: {
         nodeCollapseState: {},
@@ -75,6 +77,7 @@ export const initialState = {
         },
     },
     excludedAccountIDs: [],
+    summary: undefined,
 };
 // Create slice with reducers
 const expenseAutomationReconciliationView = createSlice({
@@ -143,7 +146,7 @@ const expenseAutomationReconciliationView = createSlice({
         fetchReconciliationSuccess: {
             reducer(draft, action) {
                 if (action.payload.accountId == null) {
-                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? []);
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? [], action.payload.reconciliation.summary);
                 }
                 else if (action.payload.reconciliation.reconciliation.length > 0 &&
                     action.payload.reconciliation.accounts.length > 0) {
@@ -287,6 +290,10 @@ const expenseAutomationReconciliationView = createSlice({
         updateSelectedDrawerAccountId: (draft, action) => {
             draft.selectedDrawerAccountId = action.payload.selectedDrawerAccountId;
         },
+        updateStatementProcessingFailed: (draft, action) => {
+            draft.statementProcessingFailed =
+                action.payload.statementProcessingFailed;
+        },
         initialiseLocalDataForSelectedAccountId: () => { },
         updateSelectedTab: (draft, action) => {
             const { selectedTab } = action.payload;
@@ -378,10 +385,22 @@ const expenseAutomationReconciliationView = createSlice({
         },
         uploadAccountStatement: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
-                fetchState: 'In-Progress',
-                error: undefined,
-            };
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUploadStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.statementParseStatus = {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                };
+                accountRecon.reparseStatementStatus = {
+                    fetchState: 'Not-Started',
+                    error: undefined,
+                };
+            }
         },
         uploadAccountStatementSuccess: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
@@ -419,6 +438,138 @@ const expenseAutomationReconciliationView = createSlice({
                 error: action.payload.error,
             };
         },
+        parseStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.statementParseStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+        },
+        parseStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = false;
+            draft.statementProcessingFailed = false;
+        },
+        parseStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = false;
+            draft.statementProcessingFailed = true;
+        },
+        reparseStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.parsedStatementData = undefined;
+                accountRecon.reparseStatementStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            }
+        },
+        reparseStatementSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            draft.statementProcessingFailed = false;
+        },
+        reparseStatementFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            draft.statementProcessingFailed = true;
+        },
+        resetReparseStatementStatus: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+                fetchState: 'Not-Started',
+                error: undefined,
+            };
+        },
+        updateParsedStatementData: (draft, action) => {
+            const { accountId, selectedPeriod, parsedStatementData } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].parsedStatementData =
+                parsedStatementData;
+        },
+        updateStatementUpdateLocalData: (draft, action) => {
+            const { accountId, selectedPeriod, statementUpdateLocalData } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                if (accountRecon.localData == null) {
+                    accountRecon.localData = {
+                        statementUpdateLocalData,
+                    };
+                }
+                else {
+                    accountRecon.localData.statementUpdateLocalData =
+                        statementUpdateLocalData;
+                }
+            }
+        },
+        submitStatementUpdate: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+                // Clear any stale date conflict from a previous attempt.
+                accountRecon.statementDateConflict = null;
+            }
+        },
+        submitStatementUpdateSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                accountRecon.statementDateConflict = null;
+                if (accountRecon.localData != null) {
+                    accountRecon.localData.statementUpdateLocalData = undefined;
+                }
+            }
+        },
+        submitStatementUpdateFailure: (draft, action) => {
+            const { accountId, selectedPeriod, dateConflict } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementUpdateStatus = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+                accountRecon.statementDateConflict = dateConflict ?? null;
+                // Keep the local edits around when the failure is a recoverable date
+                // conflict so the user can re-upload / re-edit without losing changes.
+                if (dateConflict == null && accountRecon.localData != null) {
+                    accountRecon.localData.statementUpdateLocalData = undefined;
+                }
+            }
+        },
+        clearStatementDateConflict: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon != null) {
+                accountRecon.statementDateConflict = null;
+            }
+        },
         updateAccountReconciliationLocalData: (draft, action) => {
             const { accountId, selectedPeriod, localData } = action.payload;
             const oldLocalData = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData;
@@ -524,10 +675,10 @@ const expenseAutomationReconciliationView = createSlice({
     },
 });
 // Export actions
-export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
+export const { fetchReconciliation, fetchReconciliationFailure, fetchReconciliationSuccess, saveReconciliationDetail, saveReconciliationDetailFailure, updateSelectedAccountId, setConnectionInProgressForAccount, setStatementParseInProgress, updateReconcileTabLocalData, updateReconcileTabListSortState, updateReconcileTabListScrollState, saveReconciliationDetailSuccess, updateSelectedTab, updateBalancesLocalData, initialiseLocalDataForSelectedAccountId, clearExpenseAutomationReconciliationView, updateSelectedDrawerAccountId, updateStatementProcessingFailed, updateReviewTabSortState, initializeReconciliationReviewTabLocalData, updateReviewTabLocalData, saveReconciliationReview, updateSaveReconciliationReviewFetchStatus, updateReconListScrollPosition, updateAccountReconciliationLocalData, deleteAccountStatement, deleteAccountStatementSuccess, deleteAccountStatementFailure, excludeAccountFromReconciliation, excludeAccountFromReconciliationSuccess, excludeAccountFromReconciliationFailure, includeAccountInReconciliation, includeAccountInReconciliationSuccess, includeAccountInReconciliationFailure, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, parseStatement, parseStatementSuccess, parseStatementFailure, reparseStatement, reparseStatementSuccess, reparseStatementFailure, resetReparseStatementStatus, updateParsedStatementData, updateStatementUpdateLocalData, submitStatementUpdate, submitStatementUpdateSuccess, submitStatementUpdateFailure, clearStatementDateConflict, updateStatementUploadChosen, updateNodeCollapseState, } = expenseAutomationReconciliationView.actions;
 // Export reducer
 export default expenseAutomationReconciliationView.reducer;
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts, summary) {
     draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
     draft.excludedAccountExclusionInfo = {};
     excludedAccounts.forEach((ea) => {
@@ -556,6 +707,7 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                 : undefined,
         };
     });
+    const oldReconciliationByAccountID = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID ?? {};
     draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
         accountIDs: [],
         reconciliationByAccountID: {},
@@ -579,6 +731,7 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                 paymentAccountId: account?.payment_account_id ?? undefined,
             };
         }
+        const oldRecord = oldReconciliationByAccountID[reconciliation.account_id];
         accountReconciliationRecords.reconciliationByAccountID[reconciliation.account_id] = {
             accountId: reconciliation.account_id,
             reconciliationId: reconciliation.reconciliation_id ?? undefined,
@@ -588,14 +741,25 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
             statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
             statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
             statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+            statementParseStatus: oldRecord?.statementParseStatus ?? {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            reparseStatementStatus: oldRecord?.reparseStatementStatus ?? {
+                fetchState: 'Not-Started',
+                error: undefined,
+            },
+            statementDateConflict: oldRecord?.statementDateConflict ?? null,
             localData: {
+                ...oldRecord?.localData,
                 accountSource: account?.reconciliation_source != null
                     ? toReconciliationAccountSource(account.reconciliation_source)
-                    : undefined,
+                    : oldRecord?.localData?.accountSource,
             },
             accountDetectionReason: account?.detection_info != null && account.detection_reason != null
                 ? account.detection_reason
                 : undefined,
+            parsedStatementData: oldRecord?.parsedStatementData,
         };
         accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
     });
@@ -609,6 +773,9 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
         draft.fetchState = 'Completed';
         draft.error = undefined;
     }
+    if (summary !== undefined) {
+        draft.summary = toReconciliationViewSummary(summary);
+    }
 }
 function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
     const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
@@ -676,6 +843,9 @@ const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, recon
         statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
         statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
         statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+        statementParseStatus: { fetchState: 'Not-Started', error: undefined },
+        reparseStatementStatus: { fetchState: 'Not-Started', error: undefined },
+        statementDateConflict: null,
         localData: {},
         accountDetectionReason: undefined,
     };

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

@@ -8,7 +8,7 @@ import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
 export function getExpenseAutomationFluxAnalysisView(state) {
     const { expenseAutomationFluxAnalysisViewState, monthEndCloseChecksState, monthEndCloseChecksViewState, } = state;
-    const { fetchState, error, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
+    const { fetchState, error, lastRefreshSuccessTime, refreshStatus, uiState, reviewOperatingExpenseIdsByPeriod, selectedSectionIdsByPeriod, groupsBySelectedPeriod, fluxAnalysisEntities, bulkReviewStatus, currency, totalBalancesAndVariance, } = expenseAutomationFluxAnalysisViewState;
     const fetchStateAndError = {
         fetchState,
         error,
@@ -110,6 +110,7 @@ export function getExpenseAutomationFluxAnalysisView(state) {
         refreshStatus,
         currency,
         completionStatus,
+        lastRefreshSuccessTime,
     };
 }
 // Helper function to transform operating expense to vendor view

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

@@ -43,6 +43,17 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             error: undefined,
         })
         : { fetchState: 'Not-Started', error: undefined };
+    const monthEndChecksForPeriod = selectedPeriod != null
+        ? monthEndCloseChecksState.monthEndCloseChecksByTenantId[currentTenant.tenantId]?.[toMonthYearPeriodId(selectedPeriod)]
+        : undefined;
+    const reconCheckTimeSavedHours = monthEndChecksForPeriod?.monthEndCloseCheckList?.find((check) => check.id === 'reconciliation')?.progressJson?.timeSavedHours;
+    const summaryWithTimeSaved = reconciliationViewState.summary != null
+        ? {
+            ...reconciliationViewState.summary,
+            timeSavedHours: reconCheckTimeSavedHours ??
+                reconciliationViewState.summary.timeSavedHours,
+        }
+        : undefined;
     if (accountReconForMonthYearPeriod == null) {
         return {
             bankAccounts: [],
@@ -66,6 +77,7 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             selectedTab: reconciliationViewState.selectedTab,
             monthYearPeriod: selectedPeriod,
             selectedAccountId: reconciliationViewState.selectedAccountId,
+            statementProcessingFailed: reconciliationViewState.statementProcessingFailed,
             statementUploadChosen: reconciliationViewState.statementUploadChosen,
             accountReconciliationsByAccountID: {},
             reconciliationTabsState: initialReconciliationTabsState,
@@ -115,6 +127,7 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
             includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
             excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
+            summary: summaryWithTimeSaved,
         };
     }
     const allAccountIDs = accountReconForMonthYearPeriod.accountIDs;
@@ -239,6 +252,12 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                 .refreshStatus,
             statementDeleteStatus: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
                 .statementDeleteStatus,
+            statementParseStatus: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
+                .statementParseStatus,
+            reparseStatementStatus: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
+                .reparseStatementStatus,
+            statementDateConflict: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
+                .statementDateConflict,
             statementUpdateStatus: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
                 .statementUpdateStatus,
             statementUploadStatus: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
@@ -247,6 +266,8 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                 .localData,
             statementParseInProgress: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
                 .statementParseInProgress,
+            parsedStatementData: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
+                .parsedStatementData,
             transactionFetchState: reduceAnyFetchState([
                 accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
                     .transactionFetchState,
@@ -315,6 +336,9 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                 statementUpdateStatus: { fetchState: 'Not-Started' },
                 statementUploadStatus: { fetchState: 'Not-Started' },
                 statementDeleteStatus: { fetchState: 'Not-Started' },
+                statementParseStatus: { fetchState: 'Not-Started' },
+                reparseStatementStatus: { fetchState: 'Not-Started' },
+                statementDateConflict: null,
                 localData: {},
                 connectionInProgress: false,
                 statementParseInProgress: false,
@@ -403,6 +427,7 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
         refreshStatus: reconciliationViewState.refreshStatus,
         selectedTab: reconciliationViewState.selectedTab,
         selectedDrawerAccountId: reconciliationViewState.selectedDrawerAccountId,
+        statementProcessingFailed: reconciliationViewState.statementProcessingFailed,
         statementUploadChosen: reconciliationViewState.statementUploadChosen,
         monthYearPeriod: selectedPeriod,
         accountReconciliationBySectionID,
@@ -423,8 +448,10 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
         excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
         includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
         excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
+        summary: summaryWithTimeSaved,
     };
 });
+export const getReparseStatementStatusByAccountId = (state, accountId) => getExpenseAutomationReconciliationView(state).accountReconciliationsByAccountID[accountId]?.reparseStatementStatus;
 export const isAccountReconReport = (reportId) => {
     return reportId.endsWith('reconciliation');
 };

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

@@ -1,4 +1,33 @@
 import { stringToUnion } from '../../../commonStateTypes/stringToUnion';
+export function toReconciliationViewSummary(payload) {
+    return {
+        accounts: {
+            done: payload.accounts.done,
+            failed: payload.accounts.failed,
+            inProgress: payload.accounts.in_progress,
+            total: payload.accounts.total,
+        },
+        accountsToConnectCount: payload.accounts_to_connect_count,
+        autoMatched: {
+            matchedTxns: payload.auto_matched.matched_txns,
+            totalTxns: payload.auto_matched.total_txns,
+        },
+        needsReview: {
+            accountCount: payload.needs_review.account_count,
+            txnCount: payload.needs_review.txn_count,
+        },
+        timeSavedHours: 0,
+        timeSavedPercentage: payload.time_saved_percentage,
+        progressBar: payload.progress_bar != null
+            ? {
+                aiPercentageShare: payload.progress_bar.ai_percentage_share,
+                completePercentage: payload.progress_bar.complete_percentage,
+                humanPercentageShare: payload.progress_bar.human_percentage_share,
+                remainingPercentage: payload.progress_bar.remaining_percentage,
+            }
+            : undefined,
+    };
+}
 export const RECONCILE_ACTIONS = [
     'reconcile',
     'save_reconcile_for_later',

package/lib/esm/view/opExByVendor/opExByVendorReducer.js

@@ -22,6 +22,10 @@ export const initialState = {
             error: undefined,
         },
     },
+    refreshStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     summaryFetchState: {
         fetchState: 'Not-Started',
         error: undefined,
@@ -259,12 +263,32 @@ const opexByVendor = createSlice({
                 [timeframe]: [],
             };
         },
+        refreshOpExByVendorReport(draft) {
+            draft.refreshStatus = { fetchState: 'In-Progress', error: undefined };
+        },
+        refreshOpExByVendorReportSuccess(draft, action) {
+            draft.refreshStatus = { fetchState: 'Completed', error: undefined };
+            if (action.payload.lastRefreshSuccessTime != null) {
+                draft.lastRefreshSuccessTime = action.payload.lastRefreshSuccessTime;
+            }
+        },
+        refreshOpExByVendorReportFailure: {
+            prepare(error) {
+                return { payload: { error } };
+            },
+            reducer(draft, action) {
+                draft.refreshStatus = {
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            },
+        },
         clearOpExByVendor(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchOpExByVendor, updateOpExByVendorReportGenerated, fetchOpExByVendorReportForTimeframe, updateOpExByVendorReportFailureForTimeframe, updateOpExByVendorReportSuccessForTimeframe, fetchOpExByVendorReportSummary, updateOpExByVendorReportSummaryFailure, updateOpExByVendorReportSummarySuccess, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, clearOpExByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorPageFetchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, } = opexByVendor.actions;
+export const { fetchOpExByVendor, updateOpExByVendorReportGenerated, fetchOpExByVendorReportForTimeframe, updateOpExByVendorReportFailureForTimeframe, updateOpExByVendorReportSuccessForTimeframe, fetchOpExByVendorReportSummary, updateOpExByVendorReportSummaryFailure, updateOpExByVendorReportSummarySuccess, updateOpExByVendorTimeFrame, updateOpExByVendorUIState, clearOpExByVendor, updateOpExByVendorAdditionalBalancesSelection, updateOpExByVendorSort, updateOpExByVendorSortOrSearchInProgress, updateOpExByVendorPageFetchInProgress, updateOpExByVendorDownloadState, clearOpExByVendorSearch, updateOpExByVendorPageLimit, updateOpExByVendorSearchString, refreshOpExByVendorReport, refreshOpExByVendorReportSuccess, refreshOpExByVendorReportFailure, } = opexByVendor.actions;
 export default opexByVendor.reducer;
 const doUpdateOpexByVendorReport = (draft, timeframe, reportPayload, queryProps) => {
     if (reportPayload.status.is_report_generated == null) {
@@ -317,10 +341,9 @@ const doUpdateOpexByVendorReportSummary = (draft, reportPayload) => {
         const report = mapReportPayloadToReport(reportPayload);
         draft.firstMonthOfFY = report.firstMonthOfFY;
         draft.bookCloseDate = report.bookCloseDate;
-        draft.lastRefreshSuccessTime =
-            reportPayload.status.last_refresh_success_time != null
-                ? date(reportPayload.status.last_refresh_success_time)
-                : undefined;
+        if (reportPayload.status.last_refresh_success_time != null) {
+            draft.lastRefreshSuccessTime = date(reportPayload.status.last_refresh_success_time);
+        }
         draft.totalOpexByVendor = combineCOABalanceGrouped(mapCOABalanceGroupedPayloadV2ToCOABalanceGrouped(reportPayload.operating_expenses, reportPayload.currency, 'month'), mapCOABalanceGroupedPayloadV2ToCOABalanceGrouped(reportPayload.operating_expenses, reportPayload.currency, 'quarter'));
         draft.summaryOpexByVendorKey = mapVendorSummaryBalances(reportPayload.operating_expenses, reportPayload.currency);
     }

package/lib/esm/view/opExByVendor/opExByVendorSelector.js

@@ -67,6 +67,7 @@ export const getOpExByVendorReport = createSelector((state) => state.opExByVendo
         filter,
         isReportGenerated: opExByVendorState.opExByVendorReportGenerated,
         lastRefreshSuccessTime: opExByVendorState.lastRefreshSuccessTime,
+        refreshStatus: opExByVendorState.refreshStatus,
         opexBalances,
         summaryBalances,
         allTimeframeTicks,

package/lib/esm/view/opExByVendor/refreshOpExByVendorReportEpic.js

@@ -0,0 +1,21 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus } from '../../responsePayload';
+import { date } from '../../zeniDayJS';
+import { refreshOpExByVendorReport, refreshOpExByVendorReportFailure, refreshOpExByVendorReportSuccess, } from './opExByVendorReducer';
+export const refreshOpExByVendorReportEpic = (actions$, _state, zeniAPI) => actions$.pipe(filter(refreshOpExByVendorReport.match), switchMap(() => {
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/reports/operating-expenses-by-vendor/refresh`)
+        .pipe(mergeMap((response) => {
+        if (response.status.code >= 200 && response.status.code < 300) {
+            const lastRefreshSuccessTime = response.status.last_refresh_success_time != null
+                ? date(response.status.last_refresh_success_time)
+                : undefined;
+            return of(refreshOpExByVendorReportSuccess({ lastRefreshSuccessTime }));
+        }
+        else {
+            return of(refreshOpExByVendorReportFailure(response.status));
+        }
+    }), catchError((error) => of(refreshOpExByVendorReportFailure(createZeniAPIStatus('Unexpected error', 'Refresh OpEx by Vendor REST API call errored out: ' +
+        JSON.stringify(error))))));
+}));