@zeniai/client-epic-state 5.0.91 → 5.0.92-betaNB1

package/lib/esm/view/companyTaskManagerView/companyTaskManagerViewReducer.js

@@ -3,7 +3,8 @@ export const initialUIState = {
     filterText: '',
     sortKey: 'dueDate',
     sortOrder: 'descending',
-    pageToken: null,
+    from: 0,
+    filters: {},
 };
 const initialMetrics = {
     closed: 0,
@@ -18,6 +19,13 @@ export const initialState = {
     metrics: initialMetrics,
     metricsFetchState: 'Not-Started',
     uiState: initialUIState,
+    cockpitContext: {
+        fetchState: 'Not-Started',
+        error: undefined,
+        companyIds: [],
+        userIds: [],
+        userGroupIds: [],
+    },
     hasValidState() {
         return this.fetchState == 'Completed';
     },
@@ -28,10 +36,11 @@ const companyTaskManagerView = createSlice({
     initialState,
     reducers: {
         fetchCompanyTaskManagerView: {
-            prepare(pageToken, sortKey, sortOrder, keepExistingListItems = true, searchString) {
+            prepare(from, sortKey, sortOrder, keepExistingListItems = true, searchString, filters) {
                 return {
                     payload: {
-                        pageToken,
+                        from,
+                        filters,
                         searchString,
                         sortKey,
                         sortOrder,
@@ -40,10 +49,10 @@ const companyTaskManagerView = createSlice({
                 };
             },
             reducer(draft, action) {
-                const { pageToken, searchString, sortKey, sortOrder, keepExistingListItems, } = action.payload;
+                const { from, searchString, sortKey, sortOrder, keepExistingListItems } = action.payload;
                 draft.uiState.sortKey = sortKey;
                 draft.uiState.sortOrder = sortOrder;
-                draft.uiState.pageToken = pageToken;
+                draft.uiState.from = from;
                 if (keepExistingListItems === false) {
                     draft.taskIds = [];
                 }
@@ -56,15 +65,14 @@ const companyTaskManagerView = createSlice({
         },
         updateCompanyTaskManagerViewOnSuccess(draft, action) {
             const { data } = action.payload;
-            const { tasks, query, total_count } = data;
+            const tasks = data.aggregations.group_by_company_name.buckets.flatMap((bucket) => bucket.tasks);
             draft.fetchState = 'Completed';
             draft.error = undefined;
             draft.taskIds = [...draft.taskIds, ...tasks.map((task) => task.task_id)];
-            // consider total count only when fetching for first time
-            if (draft.uiState.filterText === '' && draft.uiState.pageToken == null) {
-                draft.totalTaskCount = total_count;
+            if (draft.uiState.filterText === '' && draft.uiState.from === 0) {
+                draft.totalTaskCount = data.total;
             }
-            draft.uiState.pageToken = query.page_token;
+            draft.uiState.from = data.from + data.limit;
         },
         updateCompanyTaskManagerViewOnFailure: {
             reducer(draft, action) {
@@ -85,10 +93,30 @@ const companyTaskManagerView = createSlice({
         updateTaskManagerMetricsOnFailure(draft) {
             draft.metricsFetchState = 'Error';
         },
+        updateCompanyTaskManagerViewFilters(draft, action) {
+            if (action.payload.filters != null) {
+                draft.uiState.filters = action.payload.filters;
+            }
+        },
+        fetchCockpitContext(draft) {
+            draft.cockpitContext.fetchState = 'In-Progress';
+            draft.cockpitContext.error = undefined;
+        },
+        updateCockpitContextOnSuccess(draft, action) {
+            draft.cockpitContext.fetchState = 'Completed';
+            draft.cockpitContext.error = undefined;
+            draft.cockpitContext.companyIds = action.payload.companyIds;
+            draft.cockpitContext.userIds = action.payload.userIds;
+            draft.cockpitContext.userGroupIds = action.payload.userGroupIds;
+        },
+        updateCockpitContextOnFailure(draft, action) {
+            draft.cockpitContext.fetchState = 'Error';
+            draft.cockpitContext.error = action.payload;
+        },
         clearCompanyTaskManagerView(draft) {
             Object.assign(draft, initialState);
         },
     },
 });
-export const { fetchCompanyTaskManagerView, updateCompanyTaskManagerViewOnSuccess, updateCompanyTaskManagerViewOnFailure, fetchTaskManagerMetrics, updateTaskManagerMetrics, updateTaskManagerMetricsOnFailure, clearCompanyTaskManagerView, } = companyTaskManagerView.actions;
+export const { fetchCompanyTaskManagerView, updateCompanyTaskManagerViewOnSuccess, updateCompanyTaskManagerViewOnFailure, fetchTaskManagerMetrics, updateTaskManagerMetrics, updateTaskManagerMetricsOnFailure, clearCompanyTaskManagerView, updateCompanyTaskManagerViewFilters, fetchCockpitContext, updateCockpitContextOnSuccess, updateCockpitContextOnFailure, } = companyTaskManagerView.actions;
 export default companyTaskManagerView.reducer;

package/lib/esm/view/companyTaskManagerView/companyTaskManagerViewSelector.js

@@ -1,10 +1,11 @@
 import { createSelector } from '@reduxjs/toolkit';
-import { getCompanyByCompanyId } from '../../entity/company/companySelector';
+import { reduceAnyFetchState } from '../../commonStateTypes/reduceFetchState';
+import { getCompanyByCompanyId, getCompanyByCompanyIds, } from '../../entity/company/companySelector';
 import { getTagsByIds } from '../../entity/tag/tagSelector';
 import { getTaskById } from '../../entity/task/taskSelector';
 import { getUserByUserId, getUsersByUserIds, } from '../../entity/user/userSelector';
 export const getCompanyTaskManagerView = createSelector((state) => state.companyTaskManagerViewState, (state) => state.companyState, (state) => state.userState, (state) => state.taskState, (state) => state.tagState, (companyTaskManagerViewState, companyState, userState, taskState, tagState) => {
-    const { taskIds, uiState, fetchState, error, totalTaskCount, metrics, metricsFetchState, } = companyTaskManagerViewState;
+    const { taskIds, uiState, totalTaskCount, metrics, metricsFetchState } = companyTaskManagerViewState;
     const tasksList = [];
     taskIds.forEach((taskId) => {
         const task = getTaskById(taskState, taskId);
@@ -26,13 +27,22 @@ export const getCompanyTaskManagerView = createSelector((state) => state.company
             }
         }
     });
+    const allCompanyIds = companyTaskManagerViewState.cockpitContext.companyIds;
+    const companies = getCompanyByCompanyIds(companyState, allCompanyIds).map((c) => c.company);
+    const users = getUsersByUserIds(userState, companyTaskManagerViewState.cockpitContext.userIds);
+    const fetchStateAndError = reduceAnyFetchState([
+        companyTaskManagerViewState,
+        companyTaskManagerViewState.cockpitContext,
+    ]);
     return {
+        companies,
         metrics,
         metricsFetchState,
         tasksList,
         uiState,
-        fetchState,
-        error,
+        fetchState: fetchStateAndError.fetchState,
+        error: fetchStateAndError.error,
         totalTaskCount,
+        users,
     };
 });

package/lib/esm/view/companyTaskManagerView/epics/fetchCockpitContextEpic.js

@@ -0,0 +1,38 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCompanies } from '../../../entity/company/companyReducer';
+import { updateAllUsers } from '../../../entity/user/userReducer';
+import { updateAllUserGroups } from '../../../entity/userGroups/userGroupsReducer';
+import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
+import { fetchCockpitContext, updateCockpitContextOnFailure, updateCockpitContextOnSuccess, } from '../companyTaskManagerViewReducer';
+export const fetchCockpitContextEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCockpitContext.match), switchMap(() => zeniAPI
+    .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/cockpit-context`)
+    .pipe(mergeMap((response) => {
+    if (isSuccessResponse(response) && response.data != null) {
+        const companies = response.data?.companies ?? [];
+        const users = response.data?.users ?? [];
+        const userGroups = response.data?.user_groups ?? [];
+        const companyIds = companies.map((company) => company.company_id);
+        const userIds = users.map((user) => user.user_id);
+        const userGroupIds = userGroups.map((userGroup) => userGroup.id);
+        const actions = [
+            updateCompanies({
+                payload: response.data.companies,
+                schema: {},
+            }),
+            updateAllUsers({ users: response.data.users }),
+            updateAllUserGroups({
+                userGroups: response.data.user_groups,
+            }),
+            updateCockpitContextOnSuccess({
+                companyIds,
+                userIds,
+                userGroupIds,
+            }),
+        ];
+        return from(actions);
+    }
+    else {
+        return of(updateCockpitContextOnFailure(response.status));
+    }
+}), catchError((error) => of(updateCockpitContextOnFailure(createZeniAPIStatus('Unexpected error', 'Cockpit context fetch errored out' + JSON.stringify(error))))))));

package/lib/esm/view/companyTaskManagerView/epics/fetchCompanyTaskManagerViewEpic.js

@@ -1,51 +1,35 @@
 import { from } from 'rxjs';
 import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
 import { getSortOrder } from '../../../commonPayloadTypes/sortOrderPayload';
-import { updateCompanies } from '../../../entity/company/companyReducer';
 import { updateTags } from '../../../entity/tag/tagReducer';
 import { updateTasks } from '../../../entity/task/taskReducer';
-import { updateAllUsers } from '../../../entity/user/userReducer';
 import { createZeniAPIStatus, isSuccessResponse } from '../../../responsePayload';
 import { fetchCompanyTaskManagerView, updateCompanyTaskManagerViewOnFailure, updateCompanyTaskManagerViewOnSuccess, } from '../companyTaskManagerViewReducer';
-const toSortKeyPayload = (sortKey) => {
-    switch (sortKey) {
-        case 'taskName':
-            return 'name';
-        case 'dueDate':
-            return 'due_date';
-        case 'createdBy':
-            return 'created_by';
-        case 'name':
-            return 'company_name';
-        default:
-            return sortKey;
-    }
-};
+const DEFAULT_PAGE_SIZE = 100;
 export const fetchCompanyTaskManagerViewEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCompanyTaskManagerView.match), switchMap((action) => {
-    const { pageToken, sortKey, sortOrder, searchString } = action.payload;
+    const { from: fromOffset, searchString, sortKey, sortOrder, filters, } = action.payload;
     const queryValue = {
-        page_token: pageToken,
+        size: DEFAULT_PAGE_SIZE,
+        from: fromOffset,
+        global_search: searchString ?? '',
         sort_by: toSortKeyPayload(sortKey),
         sort_order: getSortOrder(sortOrder),
-        search_text: searchString ?? '',
-        view: 'cockpit_task_manager_view',
+        filter_join: filters?.categoryCombinationOperator === 'AND' ? 'and' : 'or',
+        ...(filters?.categories != null && filters.categories.length > 0
+            ? { filter_by: toFilterByPayload(filters) }
+            : {}),
     };
     return zeniAPI
-        .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks?query=${encodeURIComponent(JSON.stringify(queryValue))}`)
+        .getJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/cockpit-panels/tasks-es?query=${encodeURIComponent(JSON.stringify(queryValue))}`)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
-            const tasksList = response.data.tasks;
+            const tasksList = response.data.aggregations.group_by_company_name.buckets.flatMap((bucket) => bucket.tasks);
             const actions = [
                 updateCompanyTaskManagerViewOnSuccess({
                     data: response.data,
                 }),
                 updateTasks(tasksList),
-                updateCompanies({
-                    payload: response.data.companies,
-                    schema: {},
-                }),
-                updateTags(tasksList.map((task) => task.tags).flat()),
-                updateAllUsers({ users: response.data.users }),
+                updateTags(tasksList.flatMap((task) => task.tags)),
             ];
             return from(actions);
         }
@@ -62,3 +46,28 @@ export const fetchCompanyTaskManagerViewEpic = (actions$, _state$, zeniAPI) => a
         return from(actions);
     }));
 }));
+const toSortKeyPayload = (sortKey) => {
+    switch (sortKey) {
+        case 'taskName':
+            return 'name';
+        case 'dueDate':
+            return 'due_date';
+        case 'createdBy':
+            return 'created_by';
+        case 'name':
+            return 'company_name';
+        default:
+            return sortKey;
+    }
+};
+const toFilterByPayload = (filters) => {
+    if (filters.categories == null) {
+        return [];
+    }
+    return filters.categories.map((category) => ({
+        field: category.field ?? '',
+        operator: category.matchingOperator === 'equal' ? 'is' : 'is_not',
+        values: category.values.map((v) => String(v)),
+        join: category.valuesCombinationOperator === 'ALL' ? 'and' : 'or',
+    }));
+};

package/lib/esm/view/companyTaskManagerView/epics/updateCompanyTaskManagerViewFiltersEpic.js

@@ -0,0 +1,16 @@
+import { EMPTY, of } from 'rxjs';
+import { filter, switchMap } from 'rxjs/operators';
+import { fetchCompanyTaskManagerView, updateCompanyTaskManagerViewFilters, } from '../companyTaskManagerViewReducer';
+export const updateCompanyTaskManagerViewFiltersEpic = (actions$, state$) => actions$.pipe(filter(updateCompanyTaskManagerViewFilters.match), switchMap((action) => {
+    const filters = action.payload.filters;
+    const allCategoriesValid = filters?.categories == null
+        ? true
+        : filters?.categories?.every((category) => category.field != null &&
+            category.values != null &&
+            category.values.length > 0);
+    if (!allCategoriesValid) {
+        return EMPTY;
+    }
+    const { uiState } = state$.value.companyTaskManagerViewState;
+    return of(fetchCompanyTaskManagerView(0, uiState.sortKey, uiState.sortOrder, false, uiState.filterText, filters));
+}));

package/lib/esm/view/companyView/epic/fetchAllCockpitViewsEpic.js

@@ -21,7 +21,7 @@ export const fetchAllCockpitViewsEpic = (actions$, state$) => actions$.pipe(filt
             fetchReviewCompanyView(),
             fetchCompanyHealthMetricView(),
             fetchCompanyMetaData(),
-            fetchCompanyTaskManagerView(null, 'dueDate', 'descending', false),
+            fetchCompanyTaskManagerView(0, 'dueDate', 'descending', false),
             fetchCompanyHealthMetricConfig(),
         ]);
     }
@@ -74,7 +74,7 @@ export const fetchAllCockpitViewsEpic = (actions$, state$) => actions$.pipe(filt
         }
         if (state.companyTaskManagerViewState.fetchState !== 'In-Progress' &&
             state.companyTaskManagerViewState.hasValidState() === false) {
-            fetchActions.push(fetchCompanyTaskManagerView(null, 'dueDate', 'descending', false));
+            fetchActions.push(fetchCompanyTaskManagerView(0, 'dueDate', 'descending', false));
         }
         return from(fetchActions);
     }

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

@@ -0,0 +1,34 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { transformParseStatementPayloadToState, } from '../../payload/reconciliationPayload';
+import { parseStatement, parseStatementFailure, parseStatementSuccess, updateParsedStatementData, } from '../../reducers/reconciliationViewReducer';
+export const parseStatementEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(parseStatement.match), mergeMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId } = action.payload;
+    const parseStatementApi$ = zeniAPI.getJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`);
+    return parseStatementApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            const actions = [];
+            const transformedData = transformParseStatementPayloadToState(response.data);
+            actions.push(updateParsedStatementData({
+                accountId,
+                selectedPeriod,
+                parsedStatementData: transformedData,
+            }));
+            actions.push(parseStatementSuccess({ accountId, selectedPeriod }));
+            return from(actions);
+        }
+        else {
+            return of(parseStatementFailure({
+                accountId,
+                selectedPeriod,
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(parseStatementFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Parse Statement REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));

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

@@ -0,0 +1,42 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { toMonthYearPeriodId } from '../../../../commonStateTypes/timePeriod';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { transformStatementUpdateStateToPayload, } from '../../payload/reconciliationPayload';
+import { submitStatementUpdate, submitStatementUpdateFailure, submitStatementUpdateSuccess, } from '../../reducers/reconciliationViewReducer';
+export const updateStatementInfoEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(submitStatementUpdate.match), mergeMap((action) => {
+    const { accountId, selectedPeriod, statementUploadId } = action.payload;
+    const state = state$.value;
+    const reconciliationView = state.expenseAutomationReconciliationViewState;
+    const accountRecon = reconciliationView.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+    const localData = accountRecon?.localData?.statementUpdateLocalData;
+    if (!localData) {
+        return of(submitStatementUpdateFailure({
+            accountId,
+            selectedPeriod,
+            error: createZeniAPIStatus('Missing Data', 'No statement update data found'),
+        }));
+    }
+    const payload = transformStatementUpdateStateToPayload(localData);
+    const updateStatementApi$ = zeniAPI.putAndGetJSON(`${zeniAPI.apiEndPoints.reconciliationMicroServiceBaseUrl}/2.0/statement-uploads/${statementUploadId}`, payload);
+    return updateStatementApi$.pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) === true && response.data != null) {
+            return of(submitStatementUpdateSuccess({
+                accountId,
+                selectedPeriod,
+            }));
+        }
+        else {
+            return of(submitStatementUpdateFailure({
+                accountId,
+                selectedPeriod,
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(submitStatementUpdateFailure({
+        accountId,
+        selectedPeriod,
+        error: createZeniAPIStatus('Unexpected Error', 'Update Statement REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/expenseAutomationView/payload/reconciliationPayload.js

@@ -67,3 +67,76 @@ function createReviewTransactionPayload(accountReconciliationEntity) {
     });
     return reviewTransactionsPayload;
 }
+export function transformParseStatementPayloadToState(payload) {
+    return {
+        statementUpload: {
+            account: {
+                accountId: payload.statement_upload.account.account_id,
+                accountName: payload.statement_upload.account.account_name,
+                accountType: payload.statement_upload.account.account_type,
+                currencyCode: payload.statement_upload.account.currency_code,
+                last4Digits: payload.statement_upload.account.last_4_digits,
+            },
+            file: {
+                fileId: payload.statement_upload.file.file_id,
+                fileName: payload.statement_upload.file.file_name,
+                signedUrl: payload.statement_upload.file.signed_url,
+            },
+            statementMeta: {
+                closingBalance: payload.statement_upload.statement_meta.closing_balance,
+                openingBalance: payload.statement_upload.statement_meta.opening_balance,
+                statementDataStatus: payload.statement_upload.statement_meta.statement_data_status,
+                statementEndDate: payload.statement_upload.statement_meta.statement_end_date,
+                statementStartDate: payload.statement_upload.statement_meta.statement_start_date,
+                statementStatus: payload.statement_upload.statement_meta.statement_status,
+                statementUploadId: payload.statement_upload.statement_meta.statement_upload_id,
+                totalDeposits: payload.statement_upload.statement_meta.total_deposits,
+                totalPayments: payload.statement_upload.statement_meta.total_payments,
+            },
+            statementTransactions: payload.statement_upload.statement_transactions.map((txn) => ({
+                amount: txn.amount,
+                citations: txn.citation.map((c) => ({
+                    boundingBoxes: c.bounding_boxes,
+                    page: c.page,
+                    referenceText: c.reference_text,
+                })),
+                isUserAdded: txn.is_user_added,
+                isUserEdited: txn.is_user_edited,
+                statementTransactionId: txn.statement_transaction_id,
+                transactionDate: txn.transaction_date,
+                transactionDirection: txn.transaction_direction,
+                transactionMemo: txn.transaction_memo,
+            })),
+        },
+    };
+}
+export function transformStatementUpdateStateToPayload(localData) {
+    const { statementMeta, statementTransactions } = localData;
+    return {
+        statement_meta: {
+            opening_balance: statementMeta.openingBalance,
+            statement_end_date: statementMeta.statementEndDate,
+            statement_start_date: statementMeta.statementStartDate,
+            total_deposits: statementMeta.totalDeposits,
+            total_payments: statementMeta.totalPayments,
+        },
+        statement_transactions: {
+            added: statementTransactions.added.map((txn) => ({
+                amount: txn.amount,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+            deleted_ids: statementTransactions.deletedIds,
+            updated: statementTransactions.updated
+                .filter((txn) => txn.statementTransactionId != null)
+                .map((txn) => ({
+                amount: txn.amount,
+                statement_transaction_id: txn.statementTransactionId,
+                transaction_date: txn.transactionDate,
+                transaction_direction: txn.transactionDirection,
+                transaction_memo: txn.transactionMemo,
+            })),
+        },
+    };
+}

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;
@@ -419,6 +426,76 @@ const expenseAutomationReconciliationView = createSlice({
                 error: action.payload.error,
             };
         },
+        parseStatement: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].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;
+        },
+        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;
+        },
+        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.localData == null) {
+                accountRecon.localData = {
+                    statementUpdateLocalData,
+                };
+            }
+            else {
+                accountRecon.localData.statementUpdateLocalData =
+                    statementUpdateLocalData;
+            }
+        },
+        submitStatementUpdate: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUpdateStatus = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        submitStatementUpdateSuccess: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
+            accountRecon.statementUpdateStatus = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+            if (accountRecon.localData != null) {
+                accountRecon.localData.statementUpdateLocalData = undefined;
+            }
+        },
+        submitStatementUpdateFailure: (draft, action) => {
+            const { accountId, selectedPeriod } = action.payload;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
+            accountRecon.statementUpdateStatus = {
+                fetchState: 'Error',
+                error: action.payload.error,
+            };
+            if (accountRecon.localData != null) {
+                accountRecon.localData.statementUpdateLocalData = undefined;
+            }
+        },
         updateAccountReconciliationLocalData: (draft, action) => {
             const { accountId, selectedPeriod, localData } = action.payload;
             const oldLocalData = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData;
@@ -524,10 +601,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, updateParsedStatementData, updateStatementUpdateLocalData, submitStatementUpdate, submitStatementUpdateSuccess, submitStatementUpdateFailure, 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 +633,7 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
                 : undefined,
         };
     });
+    const oldReconciliationByAccountID = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID ?? {};
     draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)] = {
         accountIDs: [],
         reconciliationByAccountID: {},
@@ -579,6 +657,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 +667,17 @@ 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: { fetchState: 'Not-Started', error: undefined },
             localData: {
                 accountSource: account?.reconciliation_source != null
                     ? toReconciliationAccountSource(account.reconciliation_source)
                     : undefined,
+                ...oldRecord?.localData,
             },
             accountDetectionReason: account?.detection_info != null && account.detection_reason != null
                 ? account.detection_reason
                 : undefined,
+            parsedStatementData: oldRecord?.parsedStatementData,
         };
         accountReconciliationRecords.accountIDs.push(reconciliation.account_id);
     });
@@ -609,6 +691,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 +761,7 @@ 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 },
         localData: {},
         accountDetectionReason: undefined,
     };