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

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

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAutoTransferRules = exports.clearRuleUpdateLocalData = exports.updateRuleLocalData = exports.updateAutoTransferRuleHistoryFetchStatus = exports.updateAutoTransferRuleHistory = exports.fetchAutoTransferRuleHistory = exports.deleteAutoTransferRuleFailure = exports.deleteAutoTransferRuleSuccess = exports.deleteAutoTransferRule = exports.updateAutoTransferRuleFailure = exports.updateAutoTransferRuleSuccess = exports.updateAutoTransferRule = exports.createAutoTransferRuleFailure = exports.createAutoTransferRuleSuccess = exports.createAutoTransferRule = exports.clearAutoTransferReviewDetail = exports.updateAutoTransferReviewDetailFailure = exports.updateAutoTransferReviewDetail = exports.fetchAutoTransferReviewDetail = exports.updateAutoTransferRulesFailure = exports.updateAutoTransferRules = exports.fetchAutoTransferRules = exports.initialState = void 0;
+const toolkit_1 = require("@reduxjs/toolkit");
+const get_1 = __importDefault(require("lodash/get"));
+const commonHistory_1 = require("../commonHistoryView/commonHistory");
+const commonHistoryPayload_1 = require("../commonHistoryView/commonHistoryPayload");
+const transferDetailPayload_1 = require("../zeniAccounts/transferDetail/transferDetailPayload");
+exports.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 = (0, toolkit_1.createSlice)({
+    name: 'autotransferRules',
+    initialState: exports.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 =
+                (0, transferDetailPayload_1.mapReviewTransferMoneyPayloadToReviewTransferMoney)(action.payload);
+        },
+        updateAutoTransferReviewDetailFailure(draft, action) {
+            draft.autoTransferReviewDetail.fetchState = 'Error';
+            draft.autoTransferReviewDetail.error = action.payload;
+        },
+        clearAutoTransferReviewDetail(draft) {
+            draft.autoTransferReviewDetail = exports.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 = (0, get_1.default)(draft.historyByRuleId, ruleId, undefined);
+                if (cacheOverride === true ||
+                    detail == null ||
+                    detail.fetchState !== 'In-Progress') {
+                    draft.historyByRuleId[ruleId] = {
+                        ...commonHistory_1.initialCommonHistory,
+                    };
+                }
+            },
+            prepare(ruleId, cacheOverride = true) {
+                return {
+                    payload: { ruleId, cacheOverride },
+                };
+            },
+        },
+        updateAutoTransferRuleHistory(draft, action) {
+            const { ruleId, historicEventsPayload } = action.payload;
+            const historicEvents = historicEventsPayload.map((historicEventPayload) => (0, commonHistoryPayload_1.toHistoricEvent)(historicEventPayload));
+            draft.historyByRuleId[ruleId] = {
+                ...commonHistory_1.initialCommonHistory,
+                fetchState: 'Completed',
+                error: undefined,
+                historicEvents,
+            };
+        },
+        updateAutoTransferRuleHistoryFetchStatus(draft, action) {
+            const { ruleId, fetchState, error } = action.payload;
+            const detail = (0, get_1.default)(draft.historyByRuleId, ruleId, undefined);
+            if (detail != null) {
+                detail.fetchState = fetchState;
+                detail.error = error;
+            }
+        },
+        clearAutoTransferRules(draft) {
+            Object.assign(draft, exports.initialState);
+        },
+    },
+});
+_a = autotransferRules.actions, exports.fetchAutoTransferRules = _a.fetchAutoTransferRules, exports.updateAutoTransferRules = _a.updateAutoTransferRules, exports.updateAutoTransferRulesFailure = _a.updateAutoTransferRulesFailure, exports.fetchAutoTransferReviewDetail = _a.fetchAutoTransferReviewDetail, exports.updateAutoTransferReviewDetail = _a.updateAutoTransferReviewDetail, exports.updateAutoTransferReviewDetailFailure = _a.updateAutoTransferReviewDetailFailure, exports.clearAutoTransferReviewDetail = _a.clearAutoTransferReviewDetail, exports.createAutoTransferRule = _a.createAutoTransferRule, exports.createAutoTransferRuleSuccess = _a.createAutoTransferRuleSuccess, exports.createAutoTransferRuleFailure = _a.createAutoTransferRuleFailure, exports.updateAutoTransferRule = _a.updateAutoTransferRule, exports.updateAutoTransferRuleSuccess = _a.updateAutoTransferRuleSuccess, exports.updateAutoTransferRuleFailure = _a.updateAutoTransferRuleFailure, exports.deleteAutoTransferRule = _a.deleteAutoTransferRule, exports.deleteAutoTransferRuleSuccess = _a.deleteAutoTransferRuleSuccess, exports.deleteAutoTransferRuleFailure = _a.deleteAutoTransferRuleFailure, exports.fetchAutoTransferRuleHistory = _a.fetchAutoTransferRuleHistory, exports.updateAutoTransferRuleHistory = _a.updateAutoTransferRuleHistory, exports.updateAutoTransferRuleHistoryFetchStatus = _a.updateAutoTransferRuleHistoryFetchStatus, exports.updateRuleLocalData = _a.updateRuleLocalData, exports.clearRuleUpdateLocalData = _a.clearRuleUpdateLocalData, exports.clearAutoTransferRules = _a.clearAutoTransferRules;
+exports.default = autotransferRules.reducer;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesSelector.d.ts

@@ -0,0 +1,24 @@
+import { FetchState, FetchStateAndError, ID } from '../../../commonStateTypes/common';
+import { SelectorView } from '../../../commonStateTypes/viewAndReport/viewAndReport';
+import { RootState } from '../../../reducer';
+import { CommonHistoryView } from '../commonHistoryView/commonHistory';
+import { FundingAccount } from '../commonSetup/setupViewSelector';
+import { TreasuryAccount } from '../treasury/treasuryTransferMoney/treasuryTransferMoneyState';
+import { ReviewTransferDetail } from '../zeniAccounts/transferDetail/transferDetailState';
+import { AutoTransferRuleLocalData } from './autoTransferRulesPayload';
+import { AutoTransferRule } from './autoTransferRulesState';
+export interface AutoTransferRulesSelectorView extends SelectorView {
+    autoTransferReviewDetail: ReviewTransferDetail;
+    createRuleFetchState: FetchStateAndError;
+    ruleDeleteStatusById: Record<ID, FetchStateAndError>;
+    rules: AutoTransferRule[];
+    ruleUpdateLocalData: AutoTransferRuleLocalData;
+    ruleUpdateStatusById: Record<ID, FetchStateAndError>;
+    transferMoneyParties: FundingAccount[];
+    transferMoneyPartiesFetchState: FetchState;
+    treasuryAccount: TreasuryAccount;
+    ruleHistory?: Record<string, CommonHistoryView>;
+}
+export declare const getAutoTransferRules: (state: RootState) => AutoTransferRulesSelectorView;
+export declare const getAutoTransferRuleById: (state: RootState, ruleId: ID) => AutoTransferRule | undefined;
+export declare const getAutoTransferRuleHistory: (state: RootState, ruleId: ID) => CommonHistoryView | undefined;

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAutoTransferRuleHistory = exports.getAutoTransferRuleById = exports.getAutoTransferRules = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const reduceFetchState_1 = require("../../../commonStateTypes/reduceFetchState");
+const setupViewSelector_1 = require("../commonSetup/setupViewSelector");
+const depositAccountListSelector_1 = require("../zeniAccounts/depositAccountList/depositAccountListSelector");
+const paymentAccountListSelector_1 = require("../zeniAccounts/paymentAccountList/paymentAccountListSelector");
+const getAutoTransferRules = (state) => {
+    const { autotransferRulesState, depositAccountState, paymentAccountState, depositAccountListState, paymentAccountListState, treasuryDetailState, } = state;
+    const { rules, error, historyByRuleId, ruleUpdateLocalData, ruleUpdateStatusById, ruleDeleteStatusById, createRuleFetchState, autoTransferReviewDetail, } = autotransferRulesState;
+    const depositAccountsView = (0, depositAccountListSelector_1.getAllDepositAccounts)(depositAccountState, depositAccountListState);
+    const paymentAccountsView = (0, paymentAccountListSelector_1.getAllPaymentAccounts)(paymentAccountState, paymentAccountListState);
+    let transferMoneyParties = [];
+    const transferMoneyPartiesFetchState = (0, reduceFetchState_1.reduceAllFetchState)([
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    const fetchState = (0, reduceFetchState_1.reduceAllFetchState)([
+        autotransferRulesState,
+        depositAccountsView,
+        paymentAccountsView,
+    ]).fetchState;
+    if (depositAccountsView.fetchState === 'Completed' &&
+        paymentAccountsView.fetchState === 'Completed') {
+        transferMoneyParties = (0, setupViewSelector_1.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,
+    };
+};
+exports.getAutoTransferRules = getAutoTransferRules;
+const getAutoTransferRuleById = (state, ruleId) => {
+    return state.autotransferRulesState.rules.find((rule) => rule.autoTransferRuleId === ruleId);
+};
+exports.getAutoTransferRuleById = getAutoTransferRuleById;
+const getAutoTransferRuleHistory = (state, ruleId) => {
+    return (0, get_1.default)(state.autotransferRulesState.historyByRuleId, ruleId, undefined);
+};
+exports.getAutoTransferRuleHistory = getAutoTransferRuleHistory;

package/lib/view/spendManagement/autotransferRules/autoTransferRulesState.d.ts

@@ -0,0 +1,38 @@
+import { FetchStateAndError, FetchedState, ID } from '../../../commonStateTypes/common';
+import { ZeniDate } from '../../../zeniDayJS';
+import { CommonHistoryView } from '../commonHistoryView/commonHistory';
+import { ReviewTransferDetail } from '../zeniAccounts/transferDetail/transferDetailState';
+import { AutoTransferRuleFrequency, AutoTransferRuleLocalData, AutoTransferRuleType } from './autoTransferRulesPayload';
+export interface AutoTransferRule {
+    amount: number;
+    autoTransferRuleId: ID;
+    currencyCode: string;
+    currencySymbol: string;
+    destinationBankAccountId: string | null;
+    frequency: AutoTransferRuleFrequency;
+    isActive: boolean;
+    isDeleted: boolean;
+    lastRunTime: string | null;
+    ruleType: AutoTransferRuleType;
+    sourceBankAccountId: string;
+    sourceBankAccountType: string;
+    createTime?: ZeniDate;
+    destinationBankAccountMetadata?: DestinationBankAccountMetadata[];
+    destinationBankAccountType?: string;
+    nextTransferDate?: ZeniDate;
+    updateTime?: ZeniDate;
+}
+export interface DestinationBankAccountMetadata {
+    accountId: string;
+    accountType: string;
+    percentage: number;
+}
+export interface AutoTransferRulesState extends FetchedState {
+    autoTransferReviewDetail: ReviewTransferDetail;
+    createRuleFetchState: FetchStateAndError;
+    historyByRuleId: Record<ID, CommonHistoryView>;
+    ruleDeleteStatusById: Record<ID, FetchStateAndError>;
+    rules: AutoTransferRule[];
+    ruleUpdateLocalData: AutoTransferRuleLocalData;
+    ruleUpdateStatusById: Record<ID, FetchStateAndError>;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/view/spendManagement/autotransferRules/epics/createAutoTransferRuleEpic.d.ts

@@ -0,0 +1,12 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { AccType, AccountTypeSubConfigCodeKeyType } from '../../billPay/billPayConfig/billPayConfigState';
+import { AutoTransferRuleLocalData, AutoTransferRuleRequestBody } from '../autoTransferRulesPayload';
+import { createAutoTransferRule, createAutoTransferRuleFailure, createAutoTransferRuleSuccess } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof createAutoTransferRule> | ReturnType<typeof createAutoTransferRuleSuccess> | ReturnType<typeof createAutoTransferRuleFailure> | ReturnType<typeof openSnackbar>;
+export declare const createAutoTransferRuleEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+export declare function mapAutoTransferRuleLocalDataToPayload(localData: AutoTransferRuleLocalData, pauseRule?: boolean, resumeRule?: boolean): AutoTransferRuleRequestBody;
+export declare const accountTypeSubConfigCodeToAccType: (code?: AccountTypeSubConfigCodeKeyType | "treasuryAccount") => AccType | "treasury_account" | undefined;

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountTypeSubConfigCodeToAccType = exports.createAutoTransferRuleEpic = void 0;
+exports.mapAutoTransferRuleLocalDataToPayload = mapAutoTransferRuleLocalDataToPayload;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const snackbarReducer_1 = require("../../../../entity/snackbar/snackbarReducer");
+const responsePayload_1 = require("../../../../responsePayload");
+const autoTransferRulesPayload_1 = require("../autoTransferRulesPayload");
+const autoTransferRulesReducer_1 = require("../autoTransferRulesReducer");
+const createAutoTransferRuleEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(autoTransferRulesReducer_1.createAutoTransferRule.match), (0, operators_1.switchMap)(() => {
+    const requestBody = mapAutoTransferRuleLocalDataToPayload(state$.value.autotransferRulesState.ruleUpdateLocalData);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto`, requestBody)
+        .pipe((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            const rule = (0, autoTransferRulesPayload_1.mapPayloadToAutoTransferRule)(response.data.auto_transfer_rule);
+            const actions = [
+                (0, autoTransferRulesReducer_1.createAutoTransferRuleSuccess)({ rule }),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'auto_transfer_rule_create',
+                    messageText: 'success',
+                    type: 'success',
+                }),
+            ];
+            return (0, rxjs_1.from)(actions);
+        }
+        else {
+            return (0, rxjs_1.from)([
+                (0, autoTransferRulesReducer_1.createAutoTransferRuleFailure)({
+                    fetchState: 'Error',
+                    error: response.status,
+                }),
+                (0, snackbarReducer_1.openSnackbar)({
+                    messageSection: 'auto_transfer_rule_create',
+                    messageText: 'failed',
+                    type: 'error',
+                    variables: [
+                        {
+                            variableName: '_api-error_',
+                            variableValue: response.status.message,
+                        },
+                    ],
+                }),
+            ]);
+        }
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, autoTransferRulesReducer_1.createAutoTransferRuleFailure)({
+        fetchState: 'Error',
+        error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Create auto transfer rule REST API call errored out ' +
+            JSON.stringify(error)),
+    }))));
+}));
+exports.createAutoTransferRuleEpic = createAutoTransferRuleEpic;
+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: (0, exports.accountTypeSubConfigCodeToAccType)(localData.destinationAccount.accType),
+        }),
+        ...(localData.destinationAccountWithPercentAllocation != null && {
+            destination_bank_account_metadata: localData.destinationAccountWithPercentAllocation.map((allocation) => ({
+                account_id: allocation.account.id,
+                account_type: (0, exports.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: (0, exports.accountTypeSubConfigCodeToAccType)(localData.sourceAccount.accType),
+        }),
+        ...(localData.firstTransferDate != null && {
+            first_transfer_date: localData.firstTransferDate.format('YYYY-MM-DD'),
+        }),
+    };
+    return payload;
+}
+const accountTypeSubConfigCodeToAccType = (code) => {
+    switch (code) {
+        case 'depositAccount':
+            return 'deposit_account';
+        case 'paymentAccount':
+            return 'payment_account';
+        case 'treasuryAccount':
+            return 'treasury_account';
+        default:
+            return undefined;
+    }
+};
+exports.accountTypeSubConfigCodeToAccType = accountTypeSubConfigCodeToAccType;

package/lib/view/spendManagement/autotransferRules/epics/deleteAutoTransferRuleEpic.d.ts

@@ -0,0 +1,8 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { deleteAutoTransferRule, deleteAutoTransferRuleFailure, deleteAutoTransferRuleSuccess } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof deleteAutoTransferRule> | ReturnType<typeof deleteAutoTransferRuleSuccess> | ReturnType<typeof deleteAutoTransferRuleFailure> | ReturnType<typeof openSnackbar>;
+export declare const deleteAutoTransferRuleEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

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

package/lib/view/spendManagement/autotransferRules/epics/fetchAutoTransferReviewDetailEpic.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchAutoTransferReviewDetail, updateAutoTransferReviewDetail, updateAutoTransferReviewDetailFailure } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof fetchAutoTransferReviewDetail> | ReturnType<typeof updateAutoTransferReviewDetail> | ReturnType<typeof updateAutoTransferReviewDetailFailure>;
+export declare const fetchAutoTransferReviewDetailEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAutoTransferReviewDetailEpic = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const autoTransferRulesReducer_1 = require("../autoTransferRulesReducer");
+const createAutoTransferRuleEpic_1 = require("./createAutoTransferRuleEpic");
+const fetchAutoTransferReviewDetailEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(autoTransferRulesReducer_1.fetchAutoTransferReviewDetail.match), (0, operators_1.switchMap)(() => {
+    const localData = state$.value.autotransferRulesState.ruleUpdateLocalData;
+    const payload = {
+        ...(localData.sourceAccount != null && {
+            from_account: {
+                account_id: localData.sourceAccount.id,
+                account_type: (0, createAutoTransferRuleEpic_1.accountTypeSubConfigCodeToAccType)(localData.sourceAccount.accType) ?? '',
+            },
+        }),
+        ...(localData.destinationAccount != null && {
+            to_account: {
+                account_id: localData.destinationAccount.id,
+                account_type: (0, createAutoTransferRuleEpic_1.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((0, operators_1.mergeMap)((response) => {
+        if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+            return (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferReviewDetail)(response.data));
+        }
+        return (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferReviewDetailFailure)(response.status));
+    }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferReviewDetailFailure)((0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch auto transfer review detail REST API call errored out ' +
+        JSON.stringify(error))))));
+}));
+exports.fetchAutoTransferReviewDetailEpic = fetchAutoTransferReviewDetailEpic;

package/lib/view/spendManagement/autotransferRules/epics/fetchAutoTransferRuleHistory.d.ts

@@ -0,0 +1,7 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchAutoTransferRuleHistory, updateAutoTransferRuleHistory, updateAutoTransferRuleHistoryFetchStatus } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof fetchAutoTransferRuleHistory> | ReturnType<typeof updateAutoTransferRuleHistory> | ReturnType<typeof updateAutoTransferRuleHistoryFetchStatus>;
+export declare const fetchAutoTransferRuleHistoryEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;

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

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAutoTransferRuleHistoryEpic = void 0;
+const get_1 = __importDefault(require("lodash/get"));
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const responsePayload_1 = require("../../../../responsePayload");
+const autoTransferRulesReducer_1 = require("../autoTransferRulesReducer");
+const fetchAutoTransferRuleHistoryEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(autoTransferRulesReducer_1.fetchAutoTransferRuleHistory.match), (0, operators_1.mergeMap)((action) => {
+    const { ruleId, cacheOverride } = action.payload;
+    const historyActions = [];
+    const state = state$.value;
+    const historyDetail = (0, get_1.default)(state.autotransferRulesState.historyByRuleId, ruleId, undefined);
+    if (cacheOverride === true ||
+        historyDetail == null ||
+        historyDetail.fetchState !== 'In-Progress') {
+        historyActions.push((0, autoTransferRulesReducer_1.updateAutoTransferRuleHistoryFetchStatus)({
+            ruleId,
+            fetchState: 'In-Progress',
+        }));
+        const getHistoryDetail$ = zeniAPI
+            .getJSON(`${zeniAPI.apiEndPoints.bankingMicroServiceBaseUrl}/1.0/rules/transfer/auto/${ruleId}/history`)
+            .pipe((0, operators_1.mergeMap)((response) => {
+            if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
+                return (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferRuleHistory)({
+                    ruleId,
+                    historicEventsPayload: response.data.activities,
+                }));
+            }
+            else {
+                return (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferRuleHistoryFetchStatus)({
+                    ruleId,
+                    fetchState: 'Error',
+                    error: response.status,
+                }));
+            }
+        }), (0, operators_1.catchError)((error) => (0, rxjs_1.of)((0, autoTransferRulesReducer_1.updateAutoTransferRuleHistoryFetchStatus)({
+            ruleId,
+            fetchState: 'Error',
+            error: (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Fetch auto transfer rule history REST API call errored out ' +
+                JSON.stringify(error)),
+        }))));
+        return (0, rxjs_1.concat)((0, rxjs_1.from)(historyActions), getHistoryDetail$);
+    }
+    else {
+        return (0, rxjs_1.from)(historyActions);
+    }
+}));
+exports.fetchAutoTransferRuleHistoryEpic = fetchAutoTransferRuleHistoryEpic;

package/lib/view/spendManagement/autotransferRules/epics/fetchAutoTransferRulesEpic.d.ts

@@ -0,0 +1,10 @@
+import { ActionsObservable, StateObservable } from 'redux-observable';
+import { Observable } from 'rxjs';
+import { RootState } from '../../../../reducer';
+import { ZeniAPI } from '../../../../zeniAPI';
+import { fetchTreasuryOverviewDetail } from '../../treasury/treasuryList/treasuryDetailReducer';
+import { fetchDepositAccountList } from '../../zeniAccounts/depositAccountList/depositAccountListReducer';
+import { fetchPaymentAccountList } from '../../zeniAccounts/paymentAccountList/paymentAccountListReducer';
+import { fetchAutoTransferRules, updateAutoTransferRules, updateAutoTransferRulesFailure } from '../autoTransferRulesReducer';
+export type ActionType = ReturnType<typeof fetchAutoTransferRules> | ReturnType<typeof updateAutoTransferRules> | ReturnType<typeof updateAutoTransferRulesFailure> | ReturnType<typeof fetchDepositAccountList> | ReturnType<typeof fetchPaymentAccountList> | ReturnType<typeof fetchTreasuryOverviewDetail>;
+export declare const fetchAutoTransferRulesEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;