@zeniai/client-epic-state 4.20.3-betaSS12 → 4.20.3-betaSS13

package/lib/esm/view/spendManagement/autotransferRules/autoTransferRulesPayload.js

@@ -0,0 +1,26 @@
+import { date } from '../../../zeniDayJS';
+export const mapPayloadToAutoTransferRule = (payload) => ({
+    amount: payload.amount,
+    autoTransferRuleId: payload.auto_transfer_rule_id,
+    createTime: payload.create_time != null ? date(payload.create_time) : undefined,
+    currencyCode: payload.currency_code,
+    currencySymbol: payload.currency_symbol ?? '$',
+    destinationBankAccountId: payload.destination_bank_account_id,
+    destinationBankAccountMetadata: payload.destination_bank_account_metadata?.map((m) => ({
+        accountId: m.account_id,
+        accountType: m.account_type,
+        percentage: m.percentage,
+    })) ?? undefined,
+    destinationBankAccountType: payload.destination_bank_account_type ?? undefined,
+    frequency: payload.frequency,
+    isActive: payload.is_active,
+    isDeleted: payload.is_deleted,
+    lastRunTime: payload.last_run_time,
+    nextTransferDate: payload.next_transfer_date != null
+        ? date(payload.next_transfer_date)
+        : undefined,
+    ruleType: payload.rule_type,
+    sourceBankAccountId: payload.source_bank_account_id,
+    sourceBankAccountType: payload.source_bank_account_type,
+    updateTime: payload.update_time != null ? date(payload.update_time) : undefined,
+});

package/lib/esm/view/spendManagement/autotransferRules/autoTransferRulesReducer.js

@@ -0,0 +1,199 @@
+import { createSlice } from '@reduxjs/toolkit';
+import recordGet from 'lodash/get';
+import { initialCommonHistory } from '../commonHistoryView/commonHistory';
+import { toHistoricEvent, } from '../commonHistoryView/commonHistoryPayload';
+import { mapReviewTransferMoneyPayloadToReviewTransferMoney, } from '../zeniAccounts/transferDetail/transferDetailPayload';
+export const initialState = {
+    autoTransferReviewDetail: {
+        reviewTransferMoney: {
+            isShowDailyAchLimitWarning: false,
+            dailyAchDebitLimit: {
+                amount: 0,
+                currencyCode: 'USD',
+                currencySymbol: '$',
+            },
+            transferSchedules: [],
+        },
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    historyByRuleId: {},
+    ruleDeleteStatusById: {},
+    ruleUpdateLocalData: {},
+    ruleUpdateStatusById: {},
+    rules: [],
+    fetchState: 'Not-Started',
+    error: undefined,
+    createRuleFetchState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    hasValidState() {
+        return this.fetchState === 'Completed';
+    },
+};
+const autotransferRules = createSlice({
+    name: 'autotransferRules',
+    initialState,
+    reducers: {
+        fetchAutoTransferRules: {
+            reducer(draft) {
+                draft.fetchState = 'In-Progress';
+            },
+            prepare(cacheOverride = false) {
+                return {
+                    payload: {
+                        cacheOverride,
+                    },
+                };
+            },
+        },
+        updateAutoTransferRules(draft, action) {
+            draft.rules = action.payload.rules;
+            draft.fetchState = 'Completed';
+            draft.error = undefined;
+        },
+        updateAutoTransferRulesFailure(draft, action) {
+            draft.fetchState = action.payload.fetchState;
+            draft.error = action.payload.error;
+        },
+        updateRuleLocalData(draft, action) {
+            draft.ruleUpdateLocalData = {
+                ...draft.ruleUpdateLocalData,
+                ...action.payload,
+            };
+        },
+        clearRuleUpdateLocalData(draft) {
+            draft.ruleUpdateLocalData = {};
+        },
+        fetchAutoTransferReviewDetail(draft) {
+            draft.autoTransferReviewDetail.fetchState = 'In-Progress';
+            draft.autoTransferReviewDetail.error = undefined;
+        },
+        updateAutoTransferReviewDetail(draft, action) {
+            draft.autoTransferReviewDetail.fetchState = 'Completed';
+            draft.autoTransferReviewDetail.error = undefined;
+            draft.autoTransferReviewDetail.reviewTransferMoney =
+                mapReviewTransferMoneyPayloadToReviewTransferMoney(action.payload);
+        },
+        updateAutoTransferReviewDetailFailure(draft, action) {
+            draft.autoTransferReviewDetail.fetchState = 'Error';
+            draft.autoTransferReviewDetail.error = action.payload;
+        },
+        clearAutoTransferReviewDetail(draft) {
+            draft.autoTransferReviewDetail = initialState.autoTransferReviewDetail;
+        },
+        createAutoTransferRule(draft) {
+            draft.createRuleFetchState = {
+                fetchState: 'In-Progress',
+                error: undefined,
+            };
+        },
+        createAutoTransferRuleSuccess(draft, action) {
+            draft.rules = [...draft.rules, action.payload.rule];
+            draft.createRuleFetchState = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        createAutoTransferRuleFailure(draft, action) {
+            draft.createRuleFetchState = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        updateAutoTransferRule: {
+            reducer(draft, action) {
+                draft.ruleUpdateStatusById[action.payload.ruleId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(ruleId, pauseRule, resumeRule) {
+                return { payload: { ruleId, pauseRule, resumeRule } };
+            },
+        },
+        updateAutoTransferRuleSuccess(draft, action) {
+            const updatedRule = action.payload.rule;
+            draft.rules = draft.rules.map((rule) => rule.autoTransferRuleId === updatedRule.autoTransferRuleId
+                ? updatedRule
+                : rule);
+            draft.ruleUpdateStatusById[updatedRule.autoTransferRuleId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        updateAutoTransferRuleFailure(draft, action) {
+            draft.ruleUpdateStatusById[action.payload.ruleId] = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        deleteAutoTransferRule: {
+            reducer(draft, action) {
+                draft.ruleDeleteStatusById[action.payload.ruleId] = {
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(ruleId) {
+                return { payload: { ruleId } };
+            },
+        },
+        deleteAutoTransferRuleSuccess(draft, action) {
+            const { ruleId } = action.payload;
+            draft.rules = draft.rules.filter((rule) => rule.autoTransferRuleId !== ruleId);
+            draft.ruleDeleteStatusById[ruleId] = {
+                fetchState: 'Completed',
+                error: undefined,
+            };
+        },
+        deleteAutoTransferRuleFailure(draft, action) {
+            draft.ruleDeleteStatusById[action.payload.ruleId] = {
+                fetchState: action.payload.fetchState,
+                error: action.payload.error,
+            };
+        },
+        fetchAutoTransferRuleHistory: {
+            reducer(draft, action) {
+                const { ruleId, cacheOverride } = action.payload;
+                const detail = recordGet(draft.historyByRuleId, ruleId, undefined);
+                if (cacheOverride === true ||
+                    detail == null ||
+                    detail.fetchState !== 'In-Progress') {
+                    draft.historyByRuleId[ruleId] = {
+                        ...initialCommonHistory,
+                    };
+                }
+            },
+            prepare(ruleId, cacheOverride = true) {
+                return {
+                    payload: { ruleId, cacheOverride },
+                };
+            },
+        },
+        updateAutoTransferRuleHistory(draft, action) {
+            const { ruleId, historicEventsPayload } = action.payload;
+            const historicEvents = historicEventsPayload.map((historicEventPayload) => toHistoricEvent(historicEventPayload));
+            draft.historyByRuleId[ruleId] = {
+                ...initialCommonHistory,
+                fetchState: 'Completed',
+                error: undefined,
+                historicEvents,
+            };
+        },
+        updateAutoTransferRuleHistoryFetchStatus(draft, action) {
+            const { ruleId, fetchState, error } = action.payload;
+            const detail = recordGet(draft.historyByRuleId, ruleId, undefined);
+            if (detail != null) {
+                detail.fetchState = fetchState;
+                detail.error = error;
+            }
+        },
+        clearAutoTransferRules(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { fetchAutoTransferRules, updateAutoTransferRules, updateAutoTransferRulesFailure, fetchAutoTransferReviewDetail, updateAutoTransferReviewDetail, updateAutoTransferReviewDetailFailure, clearAutoTransferReviewDetail, createAutoTransferRule, createAutoTransferRuleSuccess, createAutoTransferRuleFailure, updateAutoTransferRule, updateAutoTransferRuleSuccess, updateAutoTransferRuleFailure, deleteAutoTransferRule, deleteAutoTransferRuleSuccess, deleteAutoTransferRuleFailure, fetchAutoTransferRuleHistory, updateAutoTransferRuleHistory, updateAutoTransferRuleHistoryFetchStatus, updateRuleLocalData, clearRuleUpdateLocalData, clearAutoTransferRules, } = autotransferRules.actions;
+export default autotransferRules.reducer;

package/lib/esm/view/spendManagement/autotransferRules/autoTransferRulesSelector.js

@@ -0,0 +1,52 @@
+import recordGet from 'lodash/get';
+import { reduceAllFetchState } from '../../../commonStateTypes/reduceFetchState';
+import { getAllFundingAccounts, } from '../commonSetup/setupViewSelector';
+import { getAllDepositAccounts } from '../zeniAccounts/depositAccountList/depositAccountListSelector';
+import { getAllPaymentAccounts } from '../zeniAccounts/paymentAccountList/paymentAccountListSelector';
+export const getAutoTransferRules = (state) => {
+    const { autotransferRulesState, depositAccountState, paymentAccountState, depositAccountListState, paymentAccountListState, treasuryDetailState, } = state;
+    const { rules, error, historyByRuleId, ruleUpdateLocalData, ruleUpdateStatusById, ruleDeleteStatusById, createRuleFetchState, autoTransferReviewDetail, } = autotransferRulesState;
+    const depositAccountsView = getAllDepositAccounts(depositAccountState, depositAccountListState);
+    const paymentAccountsView = getAllPaymentAccounts(paymentAccountState, paymentAccountListState);
+    let transferMoneyParties = [];
+    const transferMoneyPartiesFetchState = reduceAllFetchState([
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    const fetchState = reduceAllFetchState([
+        autotransferRulesState,
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    if (depositAccountsView.fetchState === 'Completed' &&
+        paymentAccountsView.fetchState === 'Completed') {
+        transferMoneyParties = getAllFundingAccounts(depositAccountsView.depositAccounts, paymentAccountsView.paymentAccounts, paymentAccountListState.paymentAccountBalanceFetchStatus);
+    }
+    const treasuryAccount = {
+        accType: 'treasuryAccount',
+        label: 'Treasury',
+        id: 'treasury',
+        balance: treasuryDetailState.accountSummary?.availableBalance,
+    };
+    return {
+        autoTransferReviewDetail,
+        rules,
+        ruleUpdateLocalData,
+        ruleUpdateStatusById,
+        ruleDeleteStatusById,
+        ruleHistory: historyByRuleId,
+        treasuryAccount,
+        transferMoneyParties,
+        transferMoneyPartiesFetchState,
+        createRuleFetchState,
+        fetchState,
+        error,
+        version: 0,
+    };
+};
+export const getAutoTransferRuleById = (state, ruleId) => {
+    return state.autotransferRulesState.rules.find((rule) => rule.autoTransferRuleId === ruleId);
+};
+export const getAutoTransferRuleHistory = (state, ruleId) => {
+    return recordGet(state.autotransferRulesState.historyByRuleId, ruleId, undefined);
+};

package/lib/esm/view/spendManagement/autotransferRules/autoTransferRulesState.js

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

package/lib/esm/view/spendManagement/autotransferRules/epics/createAutoTransferRuleEpic.js

@@ -0,0 +1,100 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { mapPayloadToAutoTransferRule, } from '../autoTransferRulesPayload';
+import { createAutoTransferRule, createAutoTransferRuleFailure, createAutoTransferRuleSuccess, } from '../autoTransferRulesReducer';
+export const createAutoTransferRuleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(createAutoTransferRule.match), switchMap(() => {
+    const requestBody = mapAutoTransferRuleLocalDataToPayload(state$.value.autotransferRulesState.ruleUpdateLocalData);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto`, requestBody)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const rule = mapPayloadToAutoTransferRule(response.data.auto_transfer_rule);
+            const actions = [
+                createAutoTransferRuleSuccess({ rule }),
+                openSnackbar({
+                    messageSection: 'auto_transfer_rule_create',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return from([
+                createAutoTransferRuleFailure({
+                    fetchState: 'Error',
+                    error: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'auto_transfer_rule_create',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), catchError((error) => of(createAutoTransferRuleFailure({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create auto transfer rule REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));
+export function mapAutoTransferRuleLocalDataToPayload(localData, pauseRule, resumeRule) {
+    if (pauseRule === true) {
+        return {
+            is_active: false,
+        };
+    }
+    if (resumeRule === true) {
+        return {
+            is_active: true,
+        };
+    }
+    const payload = {
+        ...(localData.amount != null &&
+            localData.ruleType !== 'percentage_of_balance' && {
+            amount: localData.amount.amount,
+            currency_code: localData.amount.currencyCode,
+        }),
+        ...(localData.destinationAccount != null && {
+            destination_bank_account_id: localData.destinationAccount.id,
+            destination_bank_account_type: accountTypeSubConfigCodeToAccType(localData.destinationAccount.accType),
+        }),
+        ...(localData.destinationAccountWithPercentAllocation != null && {
+            destination_bank_account_metadata: localData.destinationAccountWithPercentAllocation.map((allocation) => ({
+                account_id: allocation.account.id,
+                account_type: accountTypeSubConfigCodeToAccType(allocation.account.accType),
+                percentage: allocation.percentage,
+            })),
+        }),
+        frequency: localData.frequency,
+        rule_type: localData.ruleType,
+        ...(localData.sourceAccount != null && {
+            source_bank_account_id: localData.sourceAccount.id,
+            source_bank_account_type: accountTypeSubConfigCodeToAccType(localData.sourceAccount.accType),
+        }),
+        ...(localData.firstTransferDate != null && {
+            first_transfer_date: localData.firstTransferDate.format('YYYY-MM-DD'),
+        }),
+    };
+    return payload;
+}
+export const accountTypeSubConfigCodeToAccType = (code) => {
+    switch (code) {
+        case 'depositAccount':
+            return 'deposit_account';
+        case 'paymentAccount':
+            return 'payment_account';
+        case 'treasuryAccount':
+            return 'treasury_account';
+        default:
+            return undefined;
+    }
+};

package/lib/esm/view/spendManagement/autotransferRules/epics/deleteAutoTransferRuleEpic.js

@@ -0,0 +1,48 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { deleteAutoTransferRule, deleteAutoTransferRuleFailure, deleteAutoTransferRuleSuccess, } from '../autoTransferRulesReducer';
+export const deleteAutoTransferRuleEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(deleteAutoTransferRule.match), switchMap((action) => {
+    const { ruleId } = action.payload;
+    return zeniAPI
+        .deleteAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto/${ruleId}`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            const actions = [
+                deleteAutoTransferRuleSuccess({ ruleId }),
+                openSnackbar({
+                    messageSection: 'auto_transfer_rule_delete',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return from([
+                deleteAutoTransferRuleFailure({
+                    ruleId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'auto_transfer_rule_delete',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), catchError((error) => of(deleteAutoTransferRuleFailure({
+        ruleId,
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Delete auto transfer rule REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/spendManagement/autotransferRules/epics/fetchAutoTransferReviewDetailEpic.js

@@ -0,0 +1,36 @@
+import { of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchAutoTransferReviewDetail, updateAutoTransferReviewDetail, updateAutoTransferReviewDetailFailure, } from '../autoTransferRulesReducer';
+import { accountTypeSubConfigCodeToAccType } from './createAutoTransferRuleEpic';
+export const fetchAutoTransferReviewDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchAutoTransferReviewDetail.match), switchMap(() => {
+    const localData = state$.value.autotransferRulesState.ruleUpdateLocalData;
+    const payload = {
+        ...(localData.sourceAccount != null && {
+            from_account: {
+                account_id: localData.sourceAccount.id,
+                account_type: accountTypeSubConfigCodeToAccType(localData.sourceAccount.accType) ?? '',
+            },
+        }),
+        ...(localData.destinationAccount != null && {
+            to_account: {
+                account_id: localData.destinationAccount.id,
+                account_type: accountTypeSubConfigCodeToAccType(localData.destinationAccount.accType) ?? '',
+            },
+        }),
+        ...(localData.amount != null && {
+            amount: localData.amount.amount,
+            currency_code: localData.amount.currencyCode,
+            currency_symbol: localData.amount.currencySymbol,
+        }),
+    };
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/deposit-accounts/transfers/review`, payload)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            return of(updateAutoTransferReviewDetail(response.data));
+        }
+        return of(updateAutoTransferReviewDetailFailure(response.status));
+    }), catchError((error) => of(updateAutoTransferReviewDetailFailure(createZeniAPIStatus('Unexpected Error', 'Fetch auto transfer review detail REST API call errored out ' +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/autotransferRules/epics/fetchAutoTransferRuleHistory.js

@@ -0,0 +1,45 @@
+import recordGet from 'lodash/get';
+import { concat, from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchAutoTransferRuleHistory, updateAutoTransferRuleHistory, updateAutoTransferRuleHistoryFetchStatus, } from '../autoTransferRulesReducer';
+export const fetchAutoTransferRuleHistoryEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchAutoTransferRuleHistory.match), mergeMap((action) => {
+    const { ruleId, cacheOverride } = action.payload;
+    const historyActions = [];
+    const state = state$.value;
+    const historyDetail = recordGet(state.autotransferRulesState.historyByRuleId, ruleId, undefined);
+    if (cacheOverride === true ||
+        historyDetail == null ||
+        historyDetail.fetchState !== 'In-Progress') {
+        historyActions.push(updateAutoTransferRuleHistoryFetchStatus({
+            ruleId,
+            fetchState: 'In-Progress',
+        }));
+        const getHistoryDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto/${ruleId}/history`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                return of(updateAutoTransferRuleHistory({
+                    ruleId,
+                    historicEventsPayload: response.data.activities,
+                }));
+            }
+            else {
+                return of(updateAutoTransferRuleHistoryFetchStatus({
+                    ruleId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), catchError((error) => of(updateAutoTransferRuleHistoryFetchStatus({
+            ruleId,
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Fetch auto transfer rule history REST API call errored out ' +
+                JSON.stringify(error)),
+        }))));
+        return concat(from(historyActions), getHistoryDetail$);
+    }
+    else {
+        return from(historyActions);
+    }
+}));

package/lib/esm/view/spendManagement/autotransferRules/epics/fetchAutoTransferRulesEpic.js

@@ -0,0 +1,50 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { fetchTreasuryOverviewDetail } from '../../treasury/treasuryList/treasuryDetailReducer';
+import { fetchDepositAccountList } from '../../zeniAccounts/depositAccountList/depositAccountListReducer';
+import { fetchPaymentAccountList } from '../../zeniAccounts/paymentAccountList/paymentAccountListReducer';
+import { mapPayloadToAutoTransferRule, } from '../autoTransferRulesPayload';
+import { fetchAutoTransferRules, updateAutoTransferRules, updateAutoTransferRulesFailure, } from '../autoTransferRulesReducer';
+export const fetchAutoTransferRulesEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchAutoTransferRules.match), switchMap((action) => {
+    const state = state$.value;
+    const { cacheOverride } = action.payload;
+    const { autotransferRulesState, depositAccountListState, paymentAccountListState, } = state;
+    if (cacheOverride === true ||
+        (autotransferRulesState.hasValidState() === false &&
+            autotransferRulesState.fetchState !== 'In-Progress')) {
+        return zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto/list`)
+            .pipe(mergeMap((response) => {
+            if (isSuccessResponse(response) && response.data != null) {
+                const rules = response.data.auto_transfer_rules.map(mapPayloadToAutoTransferRule);
+                const actions = [
+                    updateAutoTransferRules({ rules }),
+                ];
+                if (depositAccountListState.fetchState !== 'In-Progress' &&
+                    depositAccountListState.fetchState !== 'Completed') {
+                    actions.push(fetchDepositAccountList());
+                }
+                if (paymentAccountListState.fetchState !== 'In-Progress' &&
+                    paymentAccountListState.fetchState !== 'Completed') {
+                    actions.push(fetchPaymentAccountList());
+                }
+                actions.push(fetchTreasuryOverviewDetail(false, true));
+                return from(actions);
+            }
+            else {
+                return of(updateAutoTransferRulesFailure({
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), catchError((error) => of(updateAutoTransferRulesFailure({
+            fetchState: 'Error',
+            error: createZeniAPIStatus('Unexpected Error', 'Fetch auto transfer rules REST API call errored out ' +
+                JSON.stringify(error)),
+        }))));
+    }
+    else {
+        return from([]);
+    }
+}));

package/lib/esm/view/spendManagement/autotransferRules/epics/updateAutoTransferRuleEpic.js

@@ -0,0 +1,69 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { mapPayloadToAutoTransferRule, } from '../autoTransferRulesPayload';
+import { updateAutoTransferRule, updateAutoTransferRuleFailure, updateAutoTransferRuleSuccess, } from '../autoTransferRulesReducer';
+import { mapAutoTransferRuleLocalDataToPayload } from './createAutoTransferRuleEpic';
+export const updateAutoTransferRuleEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(updateAutoTransferRule.match), switchMap((action) => {
+    const { ruleId, pauseRule, resumeRule } = action.payload;
+    const requestBody = mapAutoTransferRuleLocalDataToPayload(state$.value.autotransferRulesState.ruleUpdateLocalData, pauseRule, resumeRule);
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto/${ruleId}`, requestBody)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response) && response.data != null) {
+            const rule = mapPayloadToAutoTransferRule(response.data.auto_transfer_rule);
+            const isPauseOrResumeOnly = Object.keys(requestBody).length === 1 &&
+                'is_active' in requestBody;
+            const messageSection = isPauseOrResumeOnly
+                ? requestBody.is_active === false
+                    ? 'auto_transfer_rule_pause'
+                    : 'auto_transfer_rule_resume'
+                : 'auto_transfer_rule_update';
+            const actions = [
+                updateAutoTransferRuleSuccess({ rule }),
+                openSnackbar({
+                    messageSection,
+                    messageText: 'success',
+                    type: 'success',
+                    variables: [
+                        {
+                            variableName: '__ruleName__',
+                            variableValue: rule.ruleType === 'minimum_balance'
+                                ? 'Maintain a Minimum Balance'
+                                : rule.ruleType === 'recurring'
+                                    ? 'Make a Recurring Transfer'
+                                    : 'Distribute Balance by Percentage',
+                        },
+                    ],
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return from([
+                updateAutoTransferRuleFailure({
+                    ruleId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'auto_transfer_rule_update',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), catchError((error) => of(updateAutoTransferRuleFailure({
+        ruleId,
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Update auto transfer rule REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));