@zeniai/client-epic-state 4.19.28 → 4.19.30

package/lib/esm/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneyEpic.js

@@ -0,0 +1,87 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { accountTypeSubConfigCodeToAccType } from '../../helpers';
+import { updateTreasuryTransactionList } from '../treasuryList/treasuryDetailReducer';
+import { executeTreasuryTransferMoney, treasuryTransferMoneySuccessOrFailure, } from './treasuryTransferMoneyReducer';
+export const treasuryTransferMoneyEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(executeTreasuryTransferMoney.match), switchMap(() => {
+    const state = state$.value;
+    const localData = state.treasuryTransferMoneyState.localData;
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/treasury-account/transactions`, { ...toTreasuryTransferMoneyPayload(localData) })
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data) {
+            const actions = [
+                updateTreasuryTransactionList({
+                    transferTransaction: response.data,
+                }),
+                treasuryTransferMoneySuccessOrFailure({
+                    fetchState: 'Completed',
+                }),
+                openSnackbar({
+                    messageSection: 'treasury_transfer_money',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return from([
+                treasuryTransferMoneySuccessOrFailure({
+                    fetchState: 'Error',
+                    error: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'treasury_transfer_money_failed',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => {
+        return from([
+            treasuryTransferMoneySuccessOrFailure({
+                fetchState: 'Error',
+                error: createZeniAPIStatus('Unexpected Error', 'Treasury transfer money REST API call errored out: ' +
+                    JSON.stringify(error)),
+            }),
+            openSnackbar({
+                messageSection: 'treasury_transfer_money_failed',
+                messageText: 'failed',
+                type: 'error',
+            }),
+        ]);
+    }));
+}));
+const toTreasuryTransferMoneyPayload = (localData) => {
+    const payload = {
+        from_account: {
+            account_type: 'treasury_account',
+        },
+        to_account: {
+            account_type: 'treasury_account',
+        },
+        amount: localData.amount.amount,
+        currency_code: localData.amount.currencyCode,
+        currency_symbol: localData.amount.currencySymbol,
+    };
+    // If fromAccount is not null, it's a transfer TO treasury_account
+    if (localData.fromAccount &&
+        localData.fromAccount?.accType !== 'treasuryAccount') {
+        payload.from_account = {
+            account_id: localData.fromAccount.id,
+            account_type: accountTypeSubConfigCodeToAccType(localData.fromAccount.accType) ?? '',
+        };
+    }
+    // If toAccount is not null, it's a transfer FROM treasury_account
+    else if (localData.toAccount &&
+        localData.toAccount?.accType !== 'treasuryAccount') {
+        payload.to_account = {
+            account_id: localData.toAccount.id,
+            account_type: accountTypeSubConfigCodeToAccType(localData.toAccount.accType) ?? '',
+        };
+    }
+    return payload;
+};

package/lib/esm/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneyPayload.js

@@ -0,0 +1,11 @@
+export const mapTreasuryTransferMoneyPayloadToTreasuryTransferMoneyResult = (payload) => {
+    return {
+        amount: payload.amount.toString(),
+        currencyCode: payload.currency_code,
+        currencySymbol: payload.currency_symbol,
+        date: payload.date,
+        description: payload.description,
+        status: payload.status,
+        transactionId: payload.transaction_id,
+    };
+};

package/lib/esm/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneyReducer.js

@@ -0,0 +1,44 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    localData: {
+        amount: {
+            amount: 0,
+            currencyCode: 'USD',
+            currencySymbol: '$',
+        },
+        fromAccount: undefined,
+        toAccount: {
+            accType: 'treasuryAccount',
+            label: 'Treasury',
+            id: 'treasury',
+            balance: undefined,
+        },
+    },
+};
+const treasuryTransferMoney = createSlice({
+    name: 'treasuryTransferMoney',
+    initialState,
+    reducers: {
+        updateTreasuryTransferMoneyLocalData: (draft, action) => {
+            draft.localData = {
+                ...draft.localData,
+                ...action.payload,
+            };
+        },
+        executeTreasuryTransferMoney(draft) {
+            draft.fetchState = 'In-Progress';
+            draft.error = undefined;
+        },
+        treasuryTransferMoneySuccessOrFailure(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        clearTreasuryTransferMoney(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { updateTreasuryTransferMoneyLocalData, executeTreasuryTransferMoney, treasuryTransferMoneySuccessOrFailure, clearTreasuryTransferMoney, } = treasuryTransferMoney.actions;
+export default treasuryTransferMoney.reducer;

package/lib/esm/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneySelector.js

@@ -0,0 +1,60 @@
+import { reduceAllFetchState } from '../../../../commonStateTypes/reduceFetchState';
+import { mapDepositAccToFundingAccount, } from '../../commonSetup/setupViewSelector';
+import { getAllDepositAccounts } from '../../zeniAccounts/depositAccountList/depositAccountListSelector';
+import { getPrimaryPaymentAccount } from '../../zeniAccounts/paymentAccountList/paymentAccountListSelector';
+export const getTreasuryTransferMoney = (state) => {
+    const { treasuryTransferMoneyState, treasuryDetailState, treasurySetupViewState, depositAccountState, paymentAccountState, depositAccountListState, paymentAccountListState, } = state;
+    const { localData, fetchState, error } = treasuryTransferMoneyState;
+    const depositAccountsView = getAllDepositAccounts(depositAccountState, depositAccountListState);
+    let transferParties = [];
+    const transferMoneyPartiesFetchState = depositAccountsView.fetchState;
+    if (depositAccountsView.fetchState === 'Completed') {
+        transferParties = depositAccountsView.depositAccounts.map((depositAcc) => mapDepositAccToFundingAccount(depositAcc));
+    }
+    const primaryPaymentAccount = getPrimaryPaymentAccount(paymentAccountState, paymentAccountListState);
+    const treasuryAccount = {
+        accType: 'treasuryAccount',
+        label: 'Treasury',
+        id: 'treasury',
+        balance: treasuryDetailState.accountSummary?.availableBalance,
+        fundAllocations: getValidFundAllocations(treasuryDetailState.accountSummary, treasurySetupViewState.treasuryFundsDetails.fundsDetails),
+    };
+    const allRequiredDataFetchState = reduceAllFetchState([
+        depositAccountsView,
+        treasuryDetailState,
+        treasurySetupViewState.currentAllocation.fetchStatus,
+        treasurySetupViewState,
+    ]).fetchState;
+    const isTransferInProgress = fetchState === 'In-Progress';
+    const canExecuteTransfer = (localData.fromAccount != null || localData.toAccount != null) &&
+        localData.amount.amount > 0 &&
+        !isTransferInProgress;
+    return {
+        treasuryTransferMoneyLocalData: localData,
+        transferMoneyParties: transferParties,
+        transferMoneyPartiesFetchState,
+        treasuryAccount,
+        allRequiredDataFetchState,
+        primaryPaymentAccount,
+        canExecuteTransfer,
+        isTransferInProgress,
+        fetchState,
+        error,
+        version: 0,
+    };
+};
+const getValidFundAllocations = (summary, fundsDetails) => {
+    // there could be entries in the allocations that are not in the fundsDetails. eg - 'CASH_USD'. These need to be ignored.
+    const FUND_ALLOCATION_TOLERANCE = 5;
+    const validFundCodes = new Set((fundsDetails ?? []).map((fund) => fund.fundCode));
+    const allocations = summary?.fundAllocations?.filter((allocation) => validFundCodes.has(allocation.fundCode));
+    const availableAmount = summary?.availableBalance?.amount;
+    const total = allocations?.reduce((sum, allocation) => sum + (allocation.amount?.amount ?? 0), 0);
+    if (availableAmount == null || total == null) {
+        return undefined;
+    }
+    // only show the allocations if the difference between available balance and total is less than $5
+    return Math.abs(availableAmount - total) <= FUND_ALLOCATION_TOLERANCE
+        ? allocations
+        : undefined;
+};

package/lib/esm/view/spendManagement/treasury/treasuryTransferMoney/treasuryTransferMoneyState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/zeniAccounts/checkDeposit/checkDepositEpic.js

@@ -0,0 +1,44 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { getFilesByFileIds } from '../../../../entity/file/fileSelector';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { depositCheck, depositCheckSuccessOrFailure, } from './checkDepositReducer';
+export const checkDepositEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(depositCheck.match), switchMap(() => {
+    const state = state$.value;
+    const localData = state.checkDepositState.localData;
+    const files = getFilesByFileIds(state.fileState, localData.fileIds);
+    const checkFront = files.filter((file) => file.documentSide === 'front')[0];
+    const checkBack = files.filter((file) => file.documentSide === 'back')[0];
+    const payload = {
+        source_of_deposit: localData.source,
+        amount: localData.amount.amount,
+        currency_code: localData.amount.currencyCode,
+        currency_symbol: localData.amount.currencySymbol,
+        check_front_file_id: checkFront?.fileId,
+        check_back_file_id: checkBack?.fileId,
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/deposit-accounts/${localData.depositTo?.id}/check-deposits`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            return of(openSnackbar({
+                messageSection: 'deposit_check',
+                messageText: 'success',
+                type: 'success',
+            }), depositCheckSuccessOrFailure({ fetchState: 'Completed' }));
+        }
+        else {
+            return of(depositCheckSuccessOrFailure({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => {
+        return of(depositCheckSuccessOrFailure({
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Check deposit REST API call errored out' +
+                JSON.stringify(error)),
+        }));
+    }));
+}));

package/lib/esm/view/spendManagement/zeniAccounts/checkDeposit/checkDepositReducer.js

@@ -0,0 +1,39 @@
+import { createSlice } from '@reduxjs/toolkit';
+export const initialState = {
+    localData: {
+        amount: {
+            amount: 0,
+            currencyCode: 'USD',
+            currencySymbol: '$',
+        },
+        depositTo: undefined,
+        source: '',
+        fileIds: [],
+    },
+    fetchState: 'Not-Started',
+    error: undefined,
+};
+const checkDeposit = createSlice({
+    name: 'checkDeposit',
+    initialState,
+    reducers: {
+        depositCheck(draft) {
+            draft.fetchState = 'In-Progress';
+        },
+        updateLocalStore(draft, action) {
+            draft.localData = action.payload;
+        },
+        updateDepositToLocalData(draft, action) {
+            draft.localData = { ...draft.localData, depositTo: action.payload };
+        },
+        depositCheckSuccessOrFailure(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        clearCheckDeposit(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { depositCheck, depositCheckSuccessOrFailure, updateLocalStore, updateDepositToLocalData, clearCheckDeposit, } = checkDeposit.actions;
+export default checkDeposit.reducer;

package/lib/esm/view/spendManagement/zeniAccounts/checkDeposit/checkDepositSelector.js

@@ -0,0 +1,28 @@
+import { getFilesByFileIds } from '../../../../entity/file/fileSelector';
+import { getFileDeleteStatusById, getFileUpdateNameStatusById, } from '../../../fileView/fileViewSelector';
+import { getAllDepositAccounts, } from '../depositAccountList/depositAccountListSelector';
+export const getCheckDepositDetail = (state) => {
+    const deleteFileStatusById = {};
+    const updateFileStatusById = {};
+    const { depositAccountState, depositAccountListState, checkDepositState, fileState, } = state;
+    const { localData, fetchState, error } = checkDepositState;
+    const depositAccountsView = getAllDepositAccounts(depositAccountState, depositAccountListState);
+    localData.fileIds.forEach((fileId) => {
+        deleteFileStatusById[fileId] = getFileDeleteStatusById(state, fileId);
+        updateFileStatusById[fileId] = getFileUpdateNameStatusById(state, fileId);
+    });
+    const files = getFilesByFileIds(fileState, localData.fileIds);
+    const checkFront = files.filter((file) => file.documentSide === 'front')[0];
+    const checkBack = files.filter((file) => file.documentSide === 'back')[0];
+    return {
+        checkDepositLocalData: localData,
+        fetchState,
+        error,
+        depositAccounts: depositAccountsView,
+        version: 0,
+        deleteFileStatusById,
+        updateFileStatusById,
+        checkFront,
+        checkBack,
+    };
+};

package/lib/esm/view/spendManagement/zeniAccounts/checkDeposit/checkDepositState.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/view/spendManagement/zeniAccounts/depositAccountDetail/depositAccountDetailPayload.js

@@ -0,0 +1,11 @@
+import { date } from '../../../../zeniDayJS';
+export const mapAccountHistoryPayloadToAccountHistory = (payload) => ({
+    date: date(payload.date),
+    balance: {
+        available: {
+            amount: payload.balances?.available ?? 0,
+            currencyCode: payload.balances?.currency_code,
+            currencySymbol: payload.balances?.currency_symbol,
+        },
+    },
+});

package/lib/esm/view/spendManagement/zeniAccounts/depositAccountDetail/depositAccountDetailReducer.js

@@ -0,0 +1,192 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { mapDepositBalancePayloadToDepositBalance, } from '../depositAccountList/depositAccountListPayload';
+import { getSummaryKey } from '../zeniAccountList/zeniAccountListReducer';
+import { mapAccountHistoryPayloadToAccountHistory, } from './depositAccountDetailPayload';
+import { initialAccountHistoryWithBalances, initialDepositAccountDetail, } from './depositAccountDetailState';
+export const initialState = {
+    depositAccountDetailById: {},
+};
+const depositAccountDetail = createSlice({
+    name: 'depositAccountDetail',
+    initialState,
+    reducers: {
+        fetchDepositAccountDetail: {
+            reducer(draft, action) {
+                const { depositAccountId } = action.payload;
+                draft.depositAccountDetailById[depositAccountId] =
+                    initialDepositAccountDetail;
+            },
+            prepare(depositAccountId, cacheOverride) {
+                return {
+                    payload: {
+                        depositAccountId,
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        fetchDepositAccount: {
+            reducer(draft, action) {
+                const { depositAccountId } = action.payload;
+                const detail = draft.depositAccountDetailById[depositAccountId];
+                if (detail == null) {
+                    draft.depositAccountDetailById[depositAccountId] = {
+                        ...initialDepositAccountDetail,
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+                else {
+                    draft.depositAccountDetailById[depositAccountId] = {
+                        ...detail,
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+            },
+            prepare(depositAccountId) {
+                return {
+                    payload: {
+                        depositAccountId,
+                    },
+                };
+            },
+        },
+        fetchAccountHistory: {
+            reducer(draft, action) {
+                const { depositAccountId } = action.payload;
+                if (draft.depositAccountDetailById[depositAccountId] != null) {
+                    draft.depositAccountDetailById[depositAccountId] = Object.assign({}, draft.depositAccountDetailById[depositAccountId], {
+                        accountHistory: {
+                            ...initialAccountHistoryWithBalances,
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        },
+                    });
+                }
+            },
+            prepare(depositAccountId) {
+                return {
+                    payload: {
+                        depositAccountId,
+                    },
+                };
+            },
+        },
+        fetchDepositAccountSuccess(draft, action) {
+            const { depositAccountId, data } = action.payload;
+            const detail = draft.depositAccountDetailById[depositAccountId];
+            if (detail != null) {
+                const summaryPayload = data?.data?.all_deposit_accounts_summary;
+                let summary = undefined;
+                if (summaryPayload != null) {
+                    const summaryPayloadKeys = Object.keys(summaryPayload);
+                    summaryPayloadKeys.forEach((summaryPayloadKey) => {
+                        const summaryKey = getSummaryKey(summaryPayloadKey);
+                        const balance = mapDepositBalancePayloadToDepositBalance(summaryPayload[summaryPayloadKey]);
+                        summary = Object.assign({}, summary, {
+                            [summaryKey]: balance,
+                        });
+                    });
+                }
+                draft.depositAccountDetailById[depositAccountId] = {
+                    ...detail,
+                    id: depositAccountId,
+                    accountSummary: summary,
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+        },
+        fetchDepositAccountFailure(draft, action) {
+            const { depositAccountId } = action.payload;
+            const detail = draft.depositAccountDetailById[depositAccountId];
+            if (detail != null) {
+                draft.depositAccountDetailById[depositAccountId] = {
+                    ...detail,
+                    fetchState: 'Error',
+                    error: action.payload.error,
+                };
+            }
+        },
+        fetchDepositAccountHistorySuccess(draft, action) {
+            const { depositAccountId, data } = action.payload;
+            const accountDetails = draft.depositAccountDetailById[depositAccountId];
+            const accountEndOfDayBalances = data?.data?.account_end_of_day_balances;
+            if (accountDetails != null && accountEndOfDayBalances != null) {
+                const accountHistoryBalances = accountEndOfDayBalances.map((account) => mapAccountHistoryPayloadToAccountHistory(account));
+                draft.depositAccountDetailById[depositAccountId] = {
+                    ...accountDetails,
+                    accountHistory: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                        accountHistoryWithBalance: accountHistoryBalances,
+                    },
+                };
+            }
+        },
+        fetchDepositAccountHistoryFailure(draft, action) {
+            const { depositAccountId, error, fetchState } = action.payload;
+            const accountDetails = draft.depositAccountDetailById[depositAccountId];
+            if (accountDetails != null) {
+                draft.depositAccountDetailById[depositAccountId] = {
+                    ...accountDetails,
+                    accountHistory: {
+                        fetchState: fetchState,
+                        error: error,
+                        accountHistoryWithBalance: initialDepositAccountDetail.accountHistory
+                            .accountHistoryWithBalance,
+                    },
+                };
+            }
+        },
+        updateDepositAccount: {
+            reducer(draft, action) {
+                const { depositAccountId, updateType } = action.payload;
+                const exisitngState = draft.depositAccountDetailById[depositAccountId];
+                if (exisitngState != null) {
+                    draft.depositAccountDetailById[depositAccountId] = {
+                        ...exisitngState,
+                        updateStatus: {
+                            ...exisitngState.updateStatus,
+                            [updateType]: {
+                                fetchState: 'In-Progress',
+                                error: undefined,
+                            },
+                        },
+                    };
+                }
+            },
+            prepare(depositAccountId, updateType, nickname) {
+                return {
+                    payload: {
+                        depositAccountId,
+                        updateType,
+                        nickname,
+                    },
+                };
+            },
+        },
+        updateDipositAccountSuccessOrFailure(draft, action) {
+            const { depositAccountId, updateType } = action.payload;
+            const exisitngState = draft.depositAccountDetailById[depositAccountId];
+            if (exisitngState != null) {
+                draft.depositAccountDetailById[depositAccountId] = {
+                    ...exisitngState,
+                    updateStatus: {
+                        ...exisitngState.updateStatus,
+                        [updateType]: {
+                            fetchState: action.payload.fetchState,
+                            error: action.payload.error,
+                        },
+                    },
+                };
+            }
+        },
+        clearDepositAccountDetail(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchDepositAccountDetail, fetchAccountHistory, fetchDepositAccount, fetchDepositAccountSuccess, fetchDepositAccountFailure, fetchDepositAccountHistorySuccess, fetchDepositAccountHistoryFailure, updateDepositAccount, updateDipositAccountSuccessOrFailure, clearDepositAccountDetail, } = depositAccountDetail.actions;
+export default depositAccountDetail.reducer;

package/lib/esm/view/spendManagement/zeniAccounts/depositAccountDetail/depositAccountDetailSelector.js

@@ -0,0 +1,81 @@
+import { reduceAllFetchState } from '../../../../commonStateTypes/reduceFetchState';
+import { getDepositAccountByDepositAccountId } from '../../../../entity/depositAccount/depositAccountSelector';
+import { getZeniAccStatements } from '../../../zeniAccStatementList/zeniAccStatementListSelector';
+import { getDepositAccountTransactionList } from '../depositAccountTransactionList/depositAccountTransactionListSelector';
+import { getZeniAccountsConfigDetail, } from '../zeniAccountsConfig/zeniAccountsConfigSelector';
+export const getDepositAccountDetailForPDF = (state, depositAccountId) => {
+    const { depositAccountState, zeniAccountDetailState } = state;
+    const depositAccount = getDepositAccountByDepositAccountId(depositAccountState, depositAccountId);
+    const zeniAccountsConfig = getZeniAccountsConfigDetail(state);
+    const zeniAccountDetail = zeniAccountDetailState.depositAccountDetailById[depositAccountId];
+    let depositAccountDetailFetchedState = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    if (zeniAccountDetail != null) {
+        depositAccountDetailFetchedState = reduceAllFetchState([
+            zeniAccountDetail,
+            zeniAccountsConfig,
+        ]);
+    }
+    return {
+        accountDetail: depositAccount,
+        zeniAccountsConfig,
+        fetchState: depositAccountDetailFetchedState.fetchState,
+        error: depositAccountDetailFetchedState.error,
+    };
+};
+export const getDepositAccountDetail = (state, depositAccountId) => {
+    const { zeniAccountDetailState, depositAccountState } = state;
+    const zeniAccountDetail = zeniAccountDetailState.depositAccountDetailById[depositAccountId];
+    const depositAccount = getDepositAccountByDepositAccountId(depositAccountState, depositAccountId);
+    const zeniAccountsConfig = getZeniAccountsConfigDetail(state);
+    const transactionListView = getDepositAccountTransactionList(state, depositAccountId, 5);
+    let accountUpdateStatus = {
+        editName: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        closeAccount: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    };
+    const statementsView = getZeniAccStatements(state, depositAccountId);
+    const accountHistory = zeniAccountDetail?.accountHistory;
+    let zeniAccountDetailFetchStateAndError = {
+        fetchState: 'Not-Started',
+        error: undefined,
+    };
+    if (zeniAccountDetail != null) {
+        zeniAccountDetailFetchStateAndError = reduceAllFetchState([
+            zeniAccountDetail,
+            transactionListView,
+            statementsView,
+        ]);
+        if (accountHistory != null) {
+            zeniAccountDetailFetchStateAndError = reduceAllFetchState([
+                zeniAccountDetailFetchStateAndError,
+                accountHistory,
+            ]);
+        }
+        accountUpdateStatus = zeniAccountDetail.updateStatus;
+    }
+    return {
+        zeniAccountsConfig,
+        accountDetail: depositAccount,
+        accountSummary: zeniAccountDetail?.accountSummary,
+        transactionList: transactionListView.transactions,
+        statements: statementsView.statements,
+        bankLetter: undefined,
+        fetchState: zeniAccountDetailFetchStateAndError.fetchState,
+        error: zeniAccountDetailFetchStateAndError.error,
+        version: 0,
+        accountHistory: zeniAccountDetail?.accountHistory ?? {
+            fetchState: 'Not-Started',
+            error: undefined,
+            accountHistoryWithBalance: [],
+        },
+        accountUpdateStatus,
+    };
+};

package/lib/esm/view/spendManagement/zeniAccounts/depositAccountDetail/depositAccountDetailState.js

@@ -0,0 +1,27 @@
+export const initialAccountHistoryWithBalances = {
+    fetchState: 'Not-Started',
+    error: undefined,
+    accountHistoryWithBalance: [],
+};
+export const initialDepositAccountDetail = {
+    id: undefined,
+    accountHistory: initialAccountHistoryWithBalances,
+    accountSummary: undefined,
+    statements: [],
+    bankLetter: undefined,
+    updateStatus: {
+        editName: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+        closeAccount: {
+            fetchState: 'Not-Started',
+            error: undefined,
+        },
+    },
+    fetchState: 'Not-Started',
+    error: undefined,
+    hasValidState() {
+        return this.fetchState == 'Completed';
+    },
+};