@zeniai/client-epic-state 4.20.3-betaML4 → 4.20.3-betaNB11

package/lib/esm/view/companyView/companyViewReducer.js

@@ -284,6 +284,31 @@ const companyView = createSlice({
                 error: status,
             };
         },
+        updateAccountingClassesEnabled: {
+            reducer(draft, 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            _action) {
+                draft.passportView.accountingClassesUpdateStatus = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(companyId, enabled) {
+                return { payload: { companyId, enabled } };
+            },
+        },
+        updateAccountingClassesEnabledSuccess(draft) {
+            draft.passportView.accountingClassesUpdateStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateAccountingClassesEnabledFailure(draft, action) {
+            draft.passportView.accountingClassesUpdateStatus = {
+                fetchState: 'Error',
+                error: action.payload.status,
+            };
+        },
         companyPassportUpdatePrimaryContact: {
             reducer(draft, action) {
                 const { primaryContact } = action.payload;
@@ -557,5 +582,5 @@ const companyView = createSlice({
         },
     },
 });
-export const { fetchCompanyPassportView, fetchAllCockpitViews, fetchOnboardingView, fetchManagementView, fetchSubscriptionView, fetchPortfolioView, fetchCompanyManagementView, companyManagementSaveUpdates, companyManagementSavePendingUpdates, companyManagementDiscardUpdates, companyManagementSaveUpdatesSuccess, companyManagementSaveUpdatesFailure, updateCompanyViewOnSuccess, updateCompanyViewOnFailure, fetchCompanyPortfolioView, fetchZeniUsers, updateZeniUsersOnSuccess, updateZeniUsersOnFailure, clearCompanyView, updateCompanyPortfolioUIState, updateCompanyManagementUIState, companyPassportSaveDataInLocalStore, deleteCompanyOfficerInLocalStore, companyPassportClearDataInLocalStore, companyPassportUpdateCompanyDetails, companyPassportUpdateCompanyDetailsSuccess, companyPassportUpdateCompanyDetailsFailure, companyPassportUpdatePrimaryContact, companyPassportUpdatePrimaryContactSuccess, companyPassportUpdatePrimaryContactFailure, companyPassportUpdateCompanyOfficer, companyPassportUpdateCompanyOfficerSuccess, companyPassportUpdateCompanyOfficerFailure, companyPassportCreateCompanyOfficers, companyPassportCreateCompanyOfficersSuccess, companyPassportCreateCompanyOfficersFailure, updateCompanyPassportLocalStoreData, saveIndustryAndIncDateInCompanyPassportLocalStore, saveCompanyPassportDetails, fetchParentSubsidiaryManagementView, updateParentSubsidiaryView, updateParentSubsidiaryViewOnFailure, updateCompanyDownloadState, fetchCompanyMetaData, updateCompanyMetaDataOnSuccess, updateCompanyMetaDataOnFailure, updateMetaDataOnSendMonthEndReport, } = companyView.actions;
+export const { fetchCompanyPassportView, fetchAllCockpitViews, fetchOnboardingView, fetchManagementView, fetchSubscriptionView, fetchPortfolioView, fetchCompanyManagementView, companyManagementSaveUpdates, companyManagementSavePendingUpdates, companyManagementDiscardUpdates, companyManagementSaveUpdatesSuccess, companyManagementSaveUpdatesFailure, updateCompanyViewOnSuccess, updateCompanyViewOnFailure, fetchCompanyPortfolioView, fetchZeniUsers, updateZeniUsersOnSuccess, updateZeniUsersOnFailure, clearCompanyView, updateCompanyPortfolioUIState, updateCompanyManagementUIState, companyPassportSaveDataInLocalStore, deleteCompanyOfficerInLocalStore, companyPassportClearDataInLocalStore, companyPassportUpdateCompanyDetails, companyPassportUpdateCompanyDetailsSuccess, companyPassportUpdateCompanyDetailsFailure, updateAccountingClassesEnabled, updateAccountingClassesEnabledSuccess, updateAccountingClassesEnabledFailure, companyPassportUpdatePrimaryContact, companyPassportUpdatePrimaryContactSuccess, companyPassportUpdatePrimaryContactFailure, companyPassportUpdateCompanyOfficer, companyPassportUpdateCompanyOfficerSuccess, companyPassportUpdateCompanyOfficerFailure, companyPassportCreateCompanyOfficers, companyPassportCreateCompanyOfficersSuccess, companyPassportCreateCompanyOfficersFailure, updateCompanyPassportLocalStoreData, saveIndustryAndIncDateInCompanyPassportLocalStore, saveCompanyPassportDetails, fetchParentSubsidiaryManagementView, updateParentSubsidiaryView, updateParentSubsidiaryViewOnFailure, updateCompanyDownloadState, fetchCompanyMetaData, updateCompanyMetaDataOnSuccess, updateCompanyMetaDataOnFailure, updateMetaDataOnSendMonthEndReport, } = companyView.actions;
 export default companyView.reducer;

package/lib/esm/view/companyView/epic/companyPassport/updateAccountingClassesEnabledEpic.js

@@ -0,0 +1,61 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCompanies } from '../../../../entity/company/companyReducer';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTenantAccountingClassesEnabled } from '../../../../entity/tenant/tenantReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { updateAccountingClassesEnabled, updateAccountingClassesEnabledFailure, updateAccountingClassesEnabledSuccess, } from '../../companyViewReducer';
+export const updateAccountingClassesEnabledEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(updateAccountingClassesEnabled.match), switchMap((action) => {
+    const { companyId, enabled } = action.payload;
+    const tenantId = Object.values(state$.value.tenantState.tenantsById).find((t) => t.companyId === companyId)?.tenantId;
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/companies/${companyId}`, { is_accounting_classes_enabled: enabled })
+        .pipe(mergeMap((response) => {
+        const companies = response.data?.companies ?? [];
+        if (isSuccessResponse(response) && companies.length > 0) {
+            const actions = [
+                updateCompanies({
+                    payload: companies,
+                    schema: {},
+                }),
+            ];
+            if (tenantId != null) {
+                actions.push(updateTenantAccountingClassesEnabled({
+                    enabled,
+                    tenantId,
+                }));
+            }
+            actions.push(updateAccountingClassesEnabledSuccess());
+            actions.push(openSnackbar({
+                messageSection: 'accounting_classes_enabled_update',
+                messageText: 'success',
+                type: 'success',
+            }));
+            return from(actions);
+        }
+        else {
+            return from([
+                updateAccountingClassesEnabledFailure({
+                    status: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'accounting_classes_enabled_update',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => from([
+        updateAccountingClassesEnabledFailure({
+            status: createZeniAPIStatus('Unexpected error', 'Update Accounting Classes Enabled errored out' +
+                (error instanceof Error
+                    ? error.message
+                    : JSON.stringify(error))),
+        }),
+        openSnackbar({
+            messageSection: 'accounting_classes_enabled_update',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/companyView/types/companyPassport/companyPassportViewState.js

@@ -1,6 +1,10 @@
 import { initialCommonState } from '../commonState';
 export const initialCompanyPassportView = {
     ...initialCommonState,
+    accountingClassesUpdateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     companyDetails: {
         localData: undefined,
         updateStatus: {

package/lib/esm/view/expenseAutomationView/epics/accountRecon/excludeAccountFromReconciliationEpic.js

@@ -0,0 +1,44 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { changeAccountKey } from '../../../../entity/account/accountReducer';
+import { getAccountKey } from '../../../../entity/account/accountState';
+import { getAccountReconByAccountIdAndSelectedPeriod } from '../../../../entity/accountRecon/accountReconSelector';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { excludeAccountFromReconciliation, excludeAccountFromReconciliationFailure, excludeAccountFromReconciliationSuccess, } from '../../reducers/reconciliationViewReducer';
+export const excludeAccountFromReconciliationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(excludeAccountFromReconciliation.match), mergeMap((action) => {
+    const { accountId } = action.payload;
+    const state = state$.value;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = state.expenseAutomationViewState.selectedPeriodByTenantId[currentTenant.tenantId];
+    const reconciliationData = getAccountReconByAccountIdAndSelectedPeriod(state, accountId, selectedPeriod);
+    const payload = {
+        account_id: accountId,
+        bank_balance: reconciliationData?.balance?.amount ?? null,
+        cleared_balance: reconciliationData?.clearedBalance?.amount ?? null,
+        variance: reconciliationData?.variance?.amount ?? null,
+    };
+    const apiUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/excluded-accounts`;
+    return zeniAPI
+        .postAndGetJSON(apiUrl, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            const newAccountKey = getAccountKey('excluded_account_reconciliation', accountId);
+            const oldAccountKey = getAccountKey('account_reconciliation', accountId);
+            return of(excludeAccountFromReconciliationSuccess({
+                account: response.data?.excluded_account ?? undefined,
+                selectedPeriod,
+            }), changeAccountKey({
+                oldKey: oldAccountKey,
+                newKey: newAccountKey,
+            }));
+        }
+        else {
+            return of(excludeAccountFromReconciliationFailure({
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(excludeAccountFromReconciliationFailure({
+        error: createZeniAPIStatus('Unexpected Error', `Exclude account from reconciliation REST API call errored out ${JSON.stringify(error)}`),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/epics/accountRecon/fetchReconciliationViewEpic.js

@@ -53,22 +53,17 @@ export const fetchReconciliationViewEpic = (actions$, state$, zeniAPI) => action
         return zeniAPI.getJSON(apiUrl).pipe(mergeMap((response) => {
             if (isSuccessResponse(response) && response.data != null) {
                 const updateActions = [];
-                updateActions.push(updateAccounts(response.data.accounts, 'account_reconciliation'));
-                updateActions.push(updateAllUsers({
+                const allTransactionsPerRecon = getAllReviewTransactionsFromReconcilePayload(response.data.reconciliation);
+                updateActions.push(updateAccounts(response.data.accounts, 'account_reconciliation'), updateAccounts(response.data.excluded_accounts ?? [], 'excluded_account_reconciliation'), updateAllUsers({
                     users: response.data.users ?? [],
                     updateType: 'merge',
-                }));
-                updateActions.push(updateFiles({ files: response.data.files ?? [] }));
-                const allTransactionsPerRecon = getAllReviewTransactionsFromReconcilePayload(response.data.reconciliation);
-                updateActions.push(updateMultipleReconcileTransactions(allTransactionsPerRecon, 'merge'));
-                updateActions.push(updateAccountRecon(selectedPeriod, response.data.reconciliation));
+                }), updateFiles({ files: response.data.files ?? [] }), updateMultipleReconcileTransactions(allTransactionsPerRecon, 'merge'), updateAccountRecon(selectedPeriod, response.data.reconciliation));
                 const reviewTabLocalData = prepareReviewTabLocalData(response.data.reconciliation[0]?.transactions?.review ?? []);
                 if (accountId != null) {
                     const selectedTransactionIds = getTransactionIdFromCheckedMatchedTransactionPayload(response.data.reconciliation[0].transactions.reconcile);
                     updateActions.push(updateReconcileTabLocalData({
                         selectedTransactionIds: selectedTransactionIds,
-                    }));
-                    updateActions.push(initializeReconciliationReviewTabLocalData(reviewTabLocalData));
+                    }), initializeReconciliationReviewTabLocalData(reviewTabLocalData));
                 }
                 updateActions.push(fetchReconciliationSuccess(selectedPeriod, response.data, refreshViewInBackground, accountId));
                 return from(updateActions);

package/lib/esm/view/expenseAutomationView/epics/accountRecon/includeAccountInReconciliationEpic.js

@@ -0,0 +1,44 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { convertToPeriod } from '../../../../commonStateTypes/timePeriod';
+import { changeAccountKey } from '../../../../entity/account/accountReducer';
+import { getAccountKey } from '../../../../entity/account/accountState';
+import { updateAccountRecon } from '../../../../entity/accountRecon/accountReconReducer';
+import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { includeAccountInReconciliation, includeAccountInReconciliationFailure, includeAccountInReconciliationSuccess, } from '../../reducers/reconciliationViewReducer';
+export const includeAccountInReconciliationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(includeAccountInReconciliation.match), mergeMap((action) => {
+    const { accountId } = action.payload;
+    const state = state$.value;
+    const currentTenant = getCurrentTenant(state);
+    const selectedPeriod = state.expenseAutomationViewState.selectedPeriodByTenantId[currentTenant.tenantId];
+    const period = convertToPeriod(selectedPeriod, true);
+    const query = JSON.stringify({
+        start_date: period.start,
+        end_date: period.end,
+    });
+    const apiUrl = `${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/1.0/reconciliation/excluded-accounts/${accountId}?query=${encodeURIComponent(query)}`;
+    return zeniAPI
+        .deleteAndGetJSON(apiUrl)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const reconciliation = response.data.reconciliation;
+            const oldAccountKey = getAccountKey('excluded_account_reconciliation', reconciliation.account_id);
+            const newAccountKey = getAccountKey('account_reconciliation', reconciliation.account_id);
+            return of(updateAccountRecon(selectedPeriod, [reconciliation]), includeAccountInReconciliationSuccess({
+                reconciliation,
+                selectedPeriod,
+            }), changeAccountKey({
+                oldKey: oldAccountKey,
+                newKey: newAccountKey,
+            }));
+        }
+        else {
+            return of(includeAccountInReconciliationFailure({
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(includeAccountInReconciliationFailure({
+        error: createZeniAPIStatus('Unexpected Error', `Include account in reconciliation REST API call errored out ${JSON.stringify(error)}`),
+    }))));
+}));

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

@@ -44,7 +44,8 @@ export const initialState = {
     uiState: {
         searchString: '',
         scrollPosition: { scrollTop: 0, scrollLeft: undefined },
-        sortKey: 'startMonth',
+        selectedMainTab: 'pending_review',
+        sortKey: 'transactionDate',
         sortOrder: 'descending',
         totalCount: 0,
         limit: 10,
@@ -380,6 +381,9 @@ const expenseAutomationJESchedulesView = createSlice({
             if (action.payload.scrollPosition != null) {
                 draft.uiState.scrollPosition = action.payload.scrollPosition;
             }
+            if (action.payload.selectedMainTab != null) {
+                draft.uiState.selectedMainTab = action.payload.selectedMainTab;
+            }
         },
         clearExpenseAutomationJESchedulesView(draft) {
             Object.assign(draft, initialState);

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

@@ -37,7 +37,15 @@ export const initialReconciliationTabsState = {
     },
 };
 export const initialActionFetchState = {
+    excludeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     excludeFetchById: {},
+    includeAccountFetch: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     reconcileFetch: {
         fetchState: 'Not-Started',
         error: undefined,
@@ -51,6 +59,7 @@ export const initialActionFetchState = {
 export const initialState = {
     accountReconciliationRecordsBySelectedPeriod: {},
     accountConnectionStatusByAccountID: {},
+    excludedAccountExclusionInfo: {},
     fetchState: 'Not-Started',
     error: undefined,
     selectedTab: 'review',
@@ -60,10 +69,12 @@ export const initialState = {
     selectedAccountId: undefined,
     statementUploadChosen: false,
     reconListUIState: {
+        nodeCollapseState: {},
         scrollPosition: {
             scrollTop: 0,
         },
     },
+    excludedAccountIDs: [],
 };
 // Create slice with reducers
 const expenseAutomationReconciliationView = createSlice({
@@ -132,7 +143,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);
+                    updateAllReconciliation(draft, action.payload.reconciliation.accounts, action.payload.selectedPeriod, action.payload.reconciliation.reconciliation, action.payload.refreshViewInBackground, action.payload.reconciliation.excluded_accounts ?? []);
                 }
                 else if (action.payload.reconciliation.reconciliation.length > 0 &&
                     action.payload.reconciliation.accounts.length > 0) {
@@ -344,6 +355,10 @@ const expenseAutomationReconciliationView = createSlice({
         updateReconListScrollPosition: (draft, action) => {
             draft.reconListUIState.scrollPosition = action.payload.scrollPosition;
         },
+        updateNodeCollapseState: (draft, action) => {
+            draft.reconListUIState.nodeCollapseState[action.payload.nodeId] =
+                action.payload.collapsed;
+        },
         setConnectionInProgressForAccount: (draft, action) => {
             if (draft.accountConnectionStatusByAccountID[action.payload.accountId] ==
                 null) {
@@ -421,6 +436,85 @@ const expenseAutomationReconciliationView = createSlice({
                 ...localData,
             };
         },
+        excludeAccountFromReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.excludeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        excludeAccountFromReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { account, selectedPeriod } = action.payload;
+            if (account != null) {
+                if (!draft.excludedAccountIDs.includes(account.account_id)) {
+                    draft.excludedAccountIDs.push(account.account_id);
+                }
+                updateExcludedAccountExclusionInfo(draft, account);
+                const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+                if (draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId]
+                    ?.accountIDs != null) {
+                    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].accountIDs.filter((id) => id !== account.account_id);
+                }
+            }
+        },
+        excludeAccountFromReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.excludeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
+        includeAccountInReconciliation: {
+            reducer(draft) {
+                draft.actionFetchState.includeAccountFetch = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        includeAccountInReconciliationSuccess: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            const { reconciliation, selectedPeriod } = action.payload;
+            if (reconciliation == null) {
+                return;
+            }
+            const accountId = reconciliation.account_id;
+            draft.excludedAccountIDs = draft.excludedAccountIDs.filter((id) => id !== accountId);
+            delete draft.excludedAccountExclusionInfo[accountId];
+            const monthYearPeriodId = toMonthYearPeriodId(selectedPeriod);
+            const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
+            if (accountReconciliationRecords != null) {
+                if (!accountReconciliationRecords.accountIDs.includes(accountId)) {
+                    accountReconciliationRecords.accountIDs.push(accountId);
+                }
+                // put this in a function
+                updateReconciliationByAccountIDOnIncludeAccount(draft, accountId, reconciliation, monthYearPeriodId);
+            }
+            draft.accountConnectionStatusByAccountID[accountId] = {
+                status: toBankStatusCodeType(reconciliation.bank_status.code),
+                connectionInProgress: false,
+                paymentAccountId: undefined,
+            };
+        },
+        includeAccountInReconciliationFailure: (draft, action) => {
+            draft.actionFetchState.includeAccountFetch = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+        },
         updateStatementUploadChosen: (draft, action) => {
             draft.statementUploadChosen = action.payload.statementUploadChosen;
         },
@@ -430,10 +524,38 @@ 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, uploadAccountStatement, uploadAccountStatementSuccess, uploadAccountStatementFailure, updateStatementUploadChosen, } = expenseAutomationReconciliationView.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 reducer
 export default expenseAutomationReconciliationView.reducer;
-function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground) {
+function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliationData, refreshViewInBackground, excludedAccounts) {
+    draft.excludedAccountIDs = excludedAccounts.map((ea) => ea.account_id);
+    draft.excludedAccountExclusionInfo = {};
+    excludedAccounts.forEach((ea) => {
+        const { exclusion_info } = ea;
+        draft.excludedAccountExclusionInfo[ea.account_id] = {
+            bankBalance: exclusion_info.bank_balance != null
+                ? {
+                    amount: exclusion_info.bank_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            clearedBalance: exclusion_info.cleared_balance != null
+                ? {
+                    amount: exclusion_info.cleared_balance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+            variance: exclusion_info.variance != null
+                ? {
+                    amount: exclusion_info.variance,
+                    currencyCode: ea.currency_code ?? 'USD',
+                    currencySymbol: ea.currency_symbol ?? '$',
+                }
+                : undefined,
+        };
+    });
     draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
         accountIDs: [],
         reconciliationByAccountID: {},
@@ -471,6 +593,9 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                     ? toReconciliationAccountSource(account.reconciliation_source)
                     : undefined,
             },
+            accountDetectionReason: account?.detection_info != null && account.detection_reason != null
+                ? account.detection_reason
+                : undefined,
         };
         accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
     });
@@ -516,3 +641,42 @@ function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accoun
         };
     }
 }
+const updateExcludedAccountExclusionInfo = (draft, account) => {
+    draft.excludedAccountExclusionInfo[account.account_id] = {
+        bankBalance: account.bank_balance != null
+            ? {
+                amount: account.bank_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        clearedBalance: account.cleared_balance != null
+            ? {
+                amount: account.cleared_balance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+        variance: account.variance != null
+            ? {
+                amount: account.variance,
+                currencyCode: account.currency_code ?? 'USD',
+                currencySymbol: account.currency_symbol ?? '$',
+            }
+            : undefined,
+    };
+};
+const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, reconciliation, monthYearPeriodId) => {
+    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].reconciliationByAccountID[accountId] = {
+        accountId,
+        reconciliationId: reconciliation.reconciliation_id ?? undefined,
+        transactionFetchState: { fetchState: 'Not-Started', error: undefined },
+        refreshStatus: { fetchState: 'Not-Started', error: undefined },
+        statementDeleteStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUploadStatus: { fetchState: 'Not-Started', error: undefined },
+        statementUpdateStatus: { fetchState: 'Not-Started', error: undefined },
+        statementParseInProgress: reconciliation.bank_status.code === 'parsing',
+        localData: {},
+        accountDetectionReason: undefined,
+    };
+};

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

@@ -1,4 +1,3 @@
 import { stringToUnion } from '../../../commonStateTypes/stringToUnion';
 export const ALL_ACCOUNT_RECON_SECTION_IDS = ['assets', 'liabilities'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const toAccountReconSectionID = (v) => stringToUnion(v, ALL_ACCOUNT_RECON_SECTION_IDS);
+export const toAccountReconSectionID = (v) => stringToUnion(v, ALL_ACCOUNT_RECON_SECTION_IDS);

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

@@ -9,6 +9,7 @@ import { getAccountsByType } from '../../../entity/account/accountSelector';
 import { getAccountReconByAccountIdAndSelectedPeriod } from '../../../entity/accountRecon/accountReconSelector';
 import { getCurrentTenant } from '../../../entity/tenant/tenantSelector';
 import { getVendorByVendorId } from '../../../entity/vendor/vendorSelector';
+import { date } from '../../../zeniDayJS';
 import { getAccountList, getNestedAccountListHierarchy, } from '../../accountList/accountListSelector';
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
 import { initialActionFetchState, initialReconciliationTabsState, initialState, } from '../reducers/reconciliationViewReducer';
@@ -90,6 +91,30 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                     totalVariancePercentage: undefined,
                 },
             },
+            excludedAccountReconciliationByAccountID: {},
+            excludedAccountReconciliationBySectionID: {
+                assets: {
+                    sectionId: 'assets',
+                    accountIDs: [],
+                    totalBankBalance: undefined,
+                    totalClearedBalance: undefined,
+                    totalReconciledBalance: undefined,
+                    totalVariance: undefined,
+                    totalVariancePercentage: undefined,
+                },
+                liabilities: {
+                    sectionId: 'liabilities',
+                    accountIDs: [],
+                    totalBankBalance: undefined,
+                    totalClearedBalance: undefined,
+                    totalReconciledBalance: undefined,
+                    totalVariance: undefined,
+                    totalVariancePercentage: undefined,
+                },
+            },
+            excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
+            includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
+            excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
         };
     }
     const allAccountIDs = accountReconForMonthYearPeriod.accountIDs;
@@ -227,6 +252,8 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
                     .transactionFetchState,
                 accountListState.byReportId.accountList,
             ]),
+            accountDetectionReason: accountReconForMonthYearPeriod.reconciliationByAccountID[accountID]
+                .accountDetectionReason,
         };
     });
     const accountReconciliationBySectionID = {
@@ -249,6 +276,88 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
             totalVariancePercentage: liabilityTotals.variancePercentage,
         },
     };
+    const bankAccountIdSet = new Set(uniqueBankAccounts.map((a) => a.accountId));
+    const creditCardIdSet = new Set(uniqueCreditCards.map((a) => a.accountId));
+    const excludedAssetAccountIDs = [];
+    const excludedLiabilityAccountIDs = [];
+    reconciliationViewState.excludedAccountIDs.forEach((accountID) => {
+        const isAsset = bankAccountIdSet.has(accountID);
+        const isLiability = creditCardIdSet.has(accountID);
+        if (!isAsset && !isLiability) {
+            return;
+        }
+        if (isAsset) {
+            excludedAssetAccountIDs.push(accountID);
+        }
+        else {
+            excludedLiabilityAccountIDs.push(accountID);
+        }
+    });
+    const excludedAccountReconciliationBySectionID = {
+        assets: {
+            sectionId: 'assets',
+            accountIDs: excludedAssetAccountIDs,
+        },
+        liabilities: {
+            sectionId: 'liabilities',
+            accountIDs: excludedLiabilityAccountIDs,
+        },
+    };
+    const excludedAccountReconciliationByAccountID = {};
+    const accountsInState = Object.values(accountState.accountsByKey);
+    const accountsInStateMap = new Map(accountsInState.map((a) => [a.accountId, a]));
+    reconciliationViewState.excludedAccountIDs.forEach((excludedAccountID) => {
+        const account = accountsInStateMap.get(excludedAccountID);
+        const exclusionInfo = reconciliationViewState.excludedAccountExclusionInfo[excludedAccountID];
+        if (account != null) {
+            excludedAccountReconciliationByAccountID[excludedAccountID] = {
+                refreshStatus: { fetchState: 'Not-Started' },
+                statementUpdateStatus: { fetchState: 'Not-Started' },
+                statementUploadStatus: { fetchState: 'Not-Started' },
+                statementDeleteStatus: { fetchState: 'Not-Started' },
+                localData: {},
+                connectionInProgress: false,
+                statementParseInProgress: false,
+                accountConnectionStatus: 'not_connected',
+                transactionFetchState: { fetchState: 'Not-Started' },
+                accountReconEntity: {
+                    account: {
+                        accountId: account.accountId,
+                        accountName: account.accountName,
+                        accountType: account.accountType,
+                        accountSubType: account.accountSubType,
+                        accountDescription: account.accountDescription,
+                        qboId: account.qboId,
+                        coaId: account.coaId,
+                        labels: account.labels,
+                    },
+                    currency: {
+                        currencyCode: exclusionInfo?.bankBalance?.currencyCode ??
+                            exclusionInfo?.clearedBalance?.currencyCode ??
+                            'USD',
+                        currencySymbol: exclusionInfo?.bankBalance?.currencySymbol ??
+                            exclusionInfo?.clearedBalance?.currencySymbol ??
+                            '$',
+                    },
+                    startDate: date(new Date().toDateString()),
+                    endDate: date(new Date().toDateString()),
+                    statementStatus: { code: 'not_found', label: 'Not Found' },
+                    transactionsToReconcile: [],
+                    transactionsToReview: [],
+                    balance: exclusionInfo?.bankBalance,
+                    clearedBalance: exclusionInfo?.clearedBalance,
+                    variance: exclusionInfo?.variance,
+                    variancePercentage: exclusionInfo?.variance != null &&
+                        exclusionInfo?.bankBalance != null &&
+                        exclusionInfo?.bankBalance.amount !== 0
+                        ? Math.abs((exclusionInfo.variance.amount /
+                            exclusionInfo.bankBalance.amount) *
+                            100)
+                        : undefined,
+                },
+            };
+        }
+    });
     const accountListNestedAccountHierarchy = getNestedAccountListHierarchy(accountListState, 'accountList');
     const classListNestedAccountHierarchy = getNestedClassListHierarchy(classListState);
     const accountsList = getAccountList(accountState, accountListState, 'accountList');
@@ -309,6 +418,11 @@ export const getExpenseAutomationReconciliationView = createSelector((state) =>
         allClassList: allClasses,
         reviewTabSelectedVendorByTransactionId,
         reconListUIState: reconciliationViewState.reconListUIState,
+        excludedAccountReconciliationBySectionID,
+        excludedAccountReconciliationByAccountID,
+        excludeAccountFetchState: reconciliationViewState.actionFetchState.excludeAccountFetch,
+        includeAccountFetchState: reconciliationViewState.actionFetchState.includeAccountFetch,
+        excludedAccountIDs: reconciliationViewState.excludedAccountIDs,
     };
 });
 export const isAccountReconReport = (reportId) => {