@zeniai/client-epic-state 4.15.84 → 4.15.85

package/lib/view/twoFactorAuthentication/sendOtpEpic.js

@@ -8,31 +8,23 @@ const vendorViewReducer_1 = require("../commonVendorView/vendorView/vendorViewRe
 const onboardingCustomerViewReducer_1 = require("../onboardingView/customerView/onboardingCustomerViewReducer");
 const settingsViewReducer_1 = require("../settingsView/settingsViewReducer");
 const cardUserOnboardingReducer_1 = require("../spendManagement/chargeCards/cardUserOnboarding/cardUserOnboardingReducer");
+const chargeCardDetailReducer_1 = require("../spendManagement/chargeCards/chargeCardDetail/chargeCardDetailReducer");
 const setupViewReducer_1 = require("../spendManagement/commonSetup/setupViewReducer");
 const twoFactorAuthenticationReducer_1 = require("./twoFactorAuthenticationReducer");
 const sendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1.filter)(twoFactorAuthenticationReducer_1.sendOtp.match), (0, operators_1.mergeMap)((action) => {
-    var _a;
     const sendOtpActions = [];
-    const { phoneNumber, twoFASource } = action.payload;
-    const tenantState = state$.value.tenantState;
-    const companyState = state$.value.companyState;
-    const { currentTenantId } = tenantState;
-    const companyId = currentTenantId != null
-        ? (_a = tenantState.tenantsById[currentTenantId]) === null || _a === void 0 ? void 0 : _a.companyId
-        : undefined;
-    const isCardsEnabled = companyId != null
-        ? companyState.companiesById[companyId].companyChargeCardInfo
-            .isChargeCardEnabled
-        : false;
+    const { phoneNumber, twoFASource, entityId } = action.payload;
     const queryPayload = {
         channel_type: 'phone',
         channel_info: {
             phone_number: phoneNumber,
         },
-        is_for_charge_cards: twoFASource === 'ChargeCard' ||
-            twoFASource === 'CardUserOnboarding' ||
-            (twoFASource === 'MyProfile' && isCardsEnabled),
     };
+    if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+        const chargeCardProviderId = state$.value.chargeCardState.chargeCardByID[entityId].cardProviderID;
+        queryPayload.provider_card_id = chargeCardProviderId;
+        queryPayload.is_for_charge_cards = true;
+    }
     switch (twoFASource) {
         case 'SpendManagementSetup':
             sendOtpActions.push((0, setupViewReducer_1.sendOtpSpendManagementSetUp)());
@@ -49,13 +41,22 @@ const sendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1
         case 'CardUserOnboarding':
             sendOtpActions.push((0, cardUserOnboardingReducer_1.sendOtpCardUserOnboarding)());
             break;
+        case 'ChargeCardHolder':
+            if (entityId != null) {
+                sendOtpActions.push((0, chargeCardDetailReducer_1.sendOtpCardHolder)({ phone: phoneNumber, chargeCardId: entityId }));
+            }
+            break;
     }
     const setOtp$ = zeniAPI
         .postAndGetJSON(`${zeniAPI.apiEndPoints.authMicroServiceBaseUrl}/1.0/otp/send`, queryPayload)
         .pipe((0, operators_1.mergeMap)((response) => {
         if ((0, responsePayload_1.isSuccessResponse)(response) && response.data != null) {
             const updateActions = [
-                (0, twoFactorAuthenticationReducer_1.sendOtpSuccess)({ otpChallenge: response.data.otp_challenge }),
+                (0, twoFactorAuthenticationReducer_1.sendOtpSuccess)({
+                    otpChallenge: response.data.otp_challenge,
+                    twoFASource,
+                    entityId,
+                }),
             ];
             switch (twoFASource) {
                 case 'SpendManagementSetup':
@@ -83,12 +84,20 @@ const sendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1
                         otpChallenge: response.data.otp_challenge,
                     }));
                     break;
+                case 'ChargeCardHolder':
+                    if (entityId != null) {
+                        updateActions.push((0, chargeCardDetailReducer_1.sendOtpCardHolderSuccess)({
+                            otpChallenge: response.data.otp_challenge,
+                            chargeCardId: entityId,
+                        }));
+                    }
+                    break;
             }
             return (0, rxjs_1.from)(updateActions);
         }
         else {
             const updateActions = [
-                (0, twoFactorAuthenticationReducer_1.sendOtpFailure)(response.status),
+                (0, twoFactorAuthenticationReducer_1.sendOtpFailure)({ error: response.status, twoFASource, entityId }),
             ];
             switch (twoFASource) {
                 case 'SpendManagementSetup':
@@ -106,12 +115,22 @@ const sendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1
                 case 'CardUserOnboarding':
                     updateActions.push((0, cardUserOnboardingReducer_1.sendOtpCardUserOnboardingFailure)(response.status));
                     break;
+                case 'ChargeCardHolder':
+                    if (entityId != null) {
+                        updateActions.push((0, chargeCardDetailReducer_1.sendOtpCardHolderFailure)({
+                            error: response.status,
+                            chargeCardId: entityId,
+                        }));
+                    }
+                    break;
             }
             return (0, rxjs_1.from)(updateActions);
         }
     }), (0, operators_1.catchError)((error) => {
         const zeniAPIStatus = (0, responsePayload_1.createZeniAPIStatus)('Unexpected Error', 'Send otp api errored out' + JSON.stringify(error));
-        const updateActions = [(0, twoFactorAuthenticationReducer_1.sendOtpFailure)(zeniAPIStatus)];
+        const updateActions = [
+            (0, twoFactorAuthenticationReducer_1.sendOtpFailure)({ error: zeniAPIStatus, twoFASource, entityId }),
+        ];
         switch (twoFASource) {
             case 'SpendManagementSetup':
                 updateActions.push((0, setupViewReducer_1.sendOtpFailureSpendManagementSetUp)(zeniAPIStatus));
@@ -128,6 +147,14 @@ const sendOtpEpic = (actions$, state$, zeniAPI) => actions$.pipe((0, operators_1
             case 'CardUserOnboarding':
                 updateActions.push((0, cardUserOnboardingReducer_1.sendOtpCardUserOnboardingFailure)(zeniAPIStatus));
                 break;
+            case 'ChargeCardHolder':
+                if (entityId != null) {
+                    updateActions.push((0, chargeCardDetailReducer_1.sendOtpCardHolderFailure)({
+                        error: zeniAPIStatus,
+                        chargeCardId: entityId,
+                    }));
+                }
+                break;
         }
         return (0, rxjs_1.from)(updateActions);
     }));

package/lib/view/twoFactorAuthentication/twoFactorAuthentication.d.ts

@@ -1,16 +1,28 @@
-import { FetchStateAndError } from '../../commonStateTypes/common';
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
 import { ZeniDate } from '../../zeniDayJS';
-export interface TwoFactorAuthenticationState {
+export interface TwoFactorAuthentication {
     sendOtpStatus: FetchStateAndError;
     otpVerificationStatus: FetchStateAndError;
-    customerToken?: CustomerToken;
+    token?: Token;
     phone?: string;
     otpChallenge?: string;
 }
-export type TwoFASourceView = 'BillPayVendor' | 'ChargeCard' | 'SpendManagementSetup' | 'CardUserOnboarding' | 'MyProfile' | 'CustomerOnboarding';
-export interface CustomerToken {
+export type TwoFactorAuthenticationWithoutToken = Omit<TwoFactorAuthentication, 'token'>;
+export declare const defaultTwoFactorAuthenticationState: TwoFactorAuthentication;
+export interface TwoFactorAuthenticationState {
+    common: TwoFactorAuthentication;
+    chargeCardHolder: Record<ID, TwoFactorAuthentication>;
+    cardUserOnboarding: TwoFactorAuthenticationWithoutToken;
+}
+export declare const COMMON_TWO_FA_SOURCE: readonly ["BillPayVendor", "SpendManagementSetup", "MyProfile", "CustomerOnboarding"];
+export declare const toCommonTwoFASource: (v: string) => "MyProfile" | "BillPayVendor" | "SpendManagementSetup" | "CustomerOnboarding";
+export type CommonTwoFASource = ReturnType<typeof toCommonTwoFASource>;
+export type TwoFASourceView = CommonTwoFASource | 'ChargeCardHolder' | 'CardUserOnboarding';
+export interface Token {
     provider: string;
     token: string;
     expiry: ZeniDate;
     message: string;
 }
+export declare const initialTwoFactorAuthenticationWithoutToken: TwoFactorAuthenticationWithoutToken;
+export declare const initialTwoFactorAuthentication: TwoFactorAuthentication;

package/lib/view/twoFactorAuthentication/twoFactorAuthentication.js

@@ -1,2 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialTwoFactorAuthentication = exports.initialTwoFactorAuthenticationWithoutToken = exports.toCommonTwoFASource = exports.COMMON_TWO_FA_SOURCE = exports.defaultTwoFactorAuthenticationState = void 0;
+const stringToUnion_1 = require("../../commonStateTypes/stringToUnion");
+exports.defaultTwoFactorAuthenticationState = {
+    sendOtpStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    otpVerificationStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+};
+exports.COMMON_TWO_FA_SOURCE = [
+    'BillPayVendor',
+    'SpendManagementSetup',
+    'MyProfile',
+    'CustomerOnboarding',
+];
+const toCommonTwoFASource = (v) => (0, stringToUnion_1.stringToUnion)(v, exports.COMMON_TWO_FA_SOURCE);
+exports.toCommonTwoFASource = toCommonTwoFASource;
+exports.initialTwoFactorAuthenticationWithoutToken = {
+    sendOtpStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    otpVerificationStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    phone: undefined,
+    otpChallenge: undefined,
+};
+exports.initialTwoFactorAuthentication = Object.assign(Object.assign({}, exports.initialTwoFactorAuthenticationWithoutToken), { token: undefined });

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationPayload.d.ts

@@ -1,5 +1,5 @@
 import { ZeniAPIResponse } from '../../responsePayload';
-import { CustomerToken } from './twoFactorAuthentication';
+import { Token } from './twoFactorAuthentication';
 interface SendOtpPayload {
     otp_challenge: string;
 }
@@ -7,14 +7,14 @@ export type SendOtpResponse = ZeniAPIResponse<SendOtpPayload>;
 interface VerifyOtpPayload {
     is_verified: boolean;
     message: string;
-    customer_token_info?: CustomerTokenPayload;
+    token_info?: TokenPayload;
 }
-export interface CustomerTokenPayload {
-    customer_token_provider: string;
-    customer_token: string;
-    customer_token_expiration_time: string;
+export interface TokenPayload {
+    token_provider: string;
+    token: string;
+    token_expiration_time: string;
     message: string;
 }
 export type VerifyOtpResponse = ZeniAPIResponse<VerifyOtpPayload>;
-export declare const toCustomerToken: (payload: CustomerTokenPayload) => CustomerToken;
+export declare const toToken: (payload: TokenPayload) => Token;
 export {};

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationPayload.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toCustomerToken = void 0;
+exports.toToken = void 0;
 const zeniDayJS_1 = require("../../zeniDayJS");
-const toCustomerToken = (payload) => ({
-    provider: payload.customer_token_provider,
-    token: payload.customer_token,
-    expiry: (0, zeniDayJS_1.date)(payload.customer_token_expiration_time),
+const toToken = (payload) => ({
+    provider: payload.token_provider,
+    token: payload.token,
+    expiry: (0, zeniDayJS_1.date)(payload.token_expiration_time),
     message: payload.message,
 });
-exports.toCustomerToken = toCustomerToken;
+exports.toToken = toToken;

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationReducer.d.ts

@@ -1,21 +1,37 @@
+import { ID } from '../../commonStateTypes/common';
 import { ZeniAPIStatus } from '../../responsePayload';
 import { TwoFASourceView, TwoFactorAuthenticationState } from './twoFactorAuthentication';
-import { CustomerTokenPayload } from './twoFactorAuthenticationPayload';
+import { TokenPayload } from './twoFactorAuthenticationPayload';
 export declare const initialState: TwoFactorAuthenticationState;
-export declare const sendOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[phoneNumber: string, twoFASource: TwoFASourceView], {
+export declare const sendOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[phoneNumber: string, twoFASource: TwoFASourceView, entityId?: string | undefined], {
     phoneNumber: string;
     twoFASource: TwoFASourceView;
-}, "twoFactorAuthentication/sendOtp", never, never>, resendOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[otpChallenge: string, twoFASource: TwoFASourceView], {
+    entityId: string | undefined;
+}, "twoFactorAuthentication/sendOtp", never, never>, resendOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[otpChallenge: string, twoFASource: TwoFASourceView, entityId?: string | undefined], {
     otpChallenge: string;
     twoFASource: TwoFASourceView;
+    entityId: string | undefined;
 }, "twoFactorAuthentication/resendOtp", never, never>, sendOtpSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
     otpChallenge: string;
-}, "twoFactorAuthentication/sendOtpSuccess">, sendOtpFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "twoFactorAuthentication/sendOtpFailure">, verifyOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[otpCode: string, otpChallenge: string, twoFASource: TwoFASourceView], {
+    twoFASource: TwoFASourceView;
+    entityId?: ID;
+}, "twoFactorAuthentication/sendOtpSuccess">, sendOtpFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+    twoFASource: TwoFASourceView;
+    entityId?: ID;
+}, "twoFactorAuthentication/sendOtpFailure">, verifyOtp: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[otpCode: string, otpChallenge: string, twoFASource: TwoFASourceView, entityId?: string | undefined], {
     otpCode: string;
     otpChallenge: string;
     twoFASource: TwoFASourceView;
+    entityId: string | undefined;
 }, "twoFactorAuthentication/verifyOtp", never, never>, verifyOtpSuccess: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
-    customerTokenPayload: CustomerTokenPayload | undefined;
-}, "twoFactorAuthentication/verifyOtpSuccess">, verifyOtpFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<ZeniAPIStatus<Record<string, unknown>>, "twoFactorAuthentication/verifyOtpFailure">, clearTwoFactorAuthentication: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"twoFactorAuthentication/clearTwoFactorAuthentication">;
+    twoFASource: TwoFASourceView;
+    tokenPayload: TokenPayload | undefined;
+    entityId?: ID;
+}, "twoFactorAuthentication/verifyOtpSuccess">, verifyOtpFailure: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    error: ZeniAPIStatus;
+    twoFASource: TwoFASourceView;
+    entityId?: ID;
+}, "twoFactorAuthentication/verifyOtpFailure">, clearTwoFactorAuthentication: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"twoFactorAuthentication/clearTwoFactorAuthentication">;
 declare const _default: import("redux").Reducer<TwoFactorAuthenticationState>;
 export default _default;

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationReducer.js

@@ -3,19 +3,12 @@ var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.clearTwoFactorAuthentication = exports.verifyOtpFailure = exports.verifyOtpSuccess = exports.verifyOtp = exports.sendOtpFailure = exports.sendOtpSuccess = exports.resendOtp = exports.sendOtp = exports.initialState = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
+const twoFactorAuthentication_1 = require("./twoFactorAuthentication");
 const twoFactorAuthenticationPayload_1 = require("./twoFactorAuthenticationPayload");
 exports.initialState = {
-    sendOtpStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    otpVerificationStatus: {
-        fetchState: 'Not-Started',
-        error: undefined,
-    },
-    customerToken: undefined,
-    phone: undefined,
-    otpChallenge: undefined,
+    common: twoFactorAuthentication_1.initialTwoFactorAuthentication,
+    chargeCardHolder: {},
+    cardUserOnboarding: twoFactorAuthentication_1.initialTwoFactorAuthenticationWithoutToken,
 };
 const twoFactorAuthentication = (0, toolkit_1.createSlice)({
     name: 'twoFactorAuthentication',
@@ -23,74 +16,197 @@ const twoFactorAuthentication = (0, toolkit_1.createSlice)({
     reducers: {
         sendOtp: {
             reducer(draft, action) {
-                draft.phone = action.payload.phoneNumber;
-                draft.sendOtpStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                draft.otpVerificationStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
+                const { phoneNumber, twoFASource, entityId } = action.payload;
+                if (twoFASource === 'CardUserOnboarding') {
+                    draft.cardUserOnboarding.phone = phoneNumber;
+                    draft.cardUserOnboarding.sendOtpStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                    draft.cardUserOnboarding.otpVerificationStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
+                }
+                else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                    draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { phone: phoneNumber, sendOtpStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        }, otpVerificationStatus: {
+                            fetchState: 'Not-Started',
+                            error: undefined,
+                        } });
+                }
+                else {
+                    draft.common.phone = phoneNumber;
+                    draft.common.sendOtpStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                    draft.common.otpVerificationStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
+                }
             },
-            prepare(phoneNumber, twoFASource) {
-                return { payload: { phoneNumber, twoFASource } };
+            prepare(phoneNumber, twoFASource, entityId) {
+                return { payload: { phoneNumber, twoFASource, entityId } };
             },
         },
         resendOtp: {
-            reducer(draft) {
-                draft.sendOtpStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
-                draft.otpVerificationStatus = {
-                    fetchState: 'Not-Started',
-                    error: undefined,
-                };
+            reducer(draft, action) {
+                const { twoFASource, entityId } = action.payload;
+                if (twoFASource === 'CardUserOnboarding') {
+                    draft.cardUserOnboarding.sendOtpStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                    draft.cardUserOnboarding.otpVerificationStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
+                }
+                else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                    draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { sendOtpStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        }, otpVerificationStatus: {
+                            fetchState: 'Not-Started',
+                            error: undefined,
+                        } });
+                }
+                else {
+                    draft.common.sendOtpStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                    draft.common.otpVerificationStatus = {
+                        fetchState: 'Not-Started',
+                        error: undefined,
+                    };
+                }
             },
-            prepare(otpChallenge, twoFASource) {
-                return { payload: { otpChallenge, twoFASource } };
+            prepare(otpChallenge, twoFASource, entityId) {
+                return { payload: { otpChallenge, twoFASource, entityId } };
             },
         },
         sendOtpSuccess(draft, action) {
-            draft.otpChallenge = action.payload.otpChallenge;
-            draft.sendOtpStatus = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
+            const { otpChallenge, twoFASource, entityId } = action.payload;
+            if (twoFASource === 'CardUserOnboarding') {
+                draft.cardUserOnboarding.otpChallenge = otpChallenge;
+                draft.cardUserOnboarding.sendOtpStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { otpChallenge: otpChallenge, sendOtpStatus: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                    } });
+            }
+            else {
+                draft.common.otpChallenge = otpChallenge;
+                draft.common.sendOtpStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
         },
         sendOtpFailure(draft, action) {
-            draft.sendOtpStatus = {
-                fetchState: 'Error',
-                error: action.payload,
-            };
+            const { error, twoFASource, entityId } = action.payload;
+            if (twoFASource === 'CardUserOnboarding') {
+                draft.cardUserOnboarding.sendOtpStatus = {
+                    fetchState: 'Error',
+                    error,
+                };
+            }
+            else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { sendOtpStatus: {
+                        fetchState: 'Error',
+                        error,
+                    } });
+            }
+            else {
+                draft.common.sendOtpStatus = {
+                    fetchState: 'Error',
+                    error,
+                };
+            }
         },
         verifyOtp: {
-            reducer(draft) {
-                draft.otpVerificationStatus = {
-                    fetchState: 'In-Progress',
-                    error: undefined,
-                };
+            reducer(draft, action) {
+                const { twoFASource, entityId } = action.payload;
+                if (twoFASource === 'CardUserOnboarding') {
+                    draft.cardUserOnboarding.otpVerificationStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
+                else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                    draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { otpVerificationStatus: {
+                            fetchState: 'In-Progress',
+                            error: undefined,
+                        } });
+                }
+                else {
+                    draft.common.otpVerificationStatus = {
+                        fetchState: 'In-Progress',
+                        error: undefined,
+                    };
+                }
             },
-            prepare(otpCode, otpChallenge, twoFASource) {
-                return { payload: { otpCode, otpChallenge, twoFASource } };
+            prepare(otpCode, otpChallenge, twoFASource, entityId) {
+                return { payload: { otpCode, otpChallenge, twoFASource, entityId } };
             },
         },
         verifyOtpSuccess(draft, action) {
-            const { customerTokenPayload } = action.payload;
-            if (customerTokenPayload != null) {
-                draft.customerToken = (0, twoFactorAuthenticationPayload_1.toCustomerToken)(customerTokenPayload);
+            const { twoFASource, tokenPayload, entityId } = action.payload;
+            if (twoFASource === 'CardUserOnboarding') {
+                draft.cardUserOnboarding.otpVerificationStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+            }
+            else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { otpVerificationStatus: {
+                        fetchState: 'Completed',
+                        error: undefined,
+                    } });
+                if (tokenPayload != null) {
+                    draft.chargeCardHolder[entityId].token = (0, twoFactorAuthenticationPayload_1.toToken)(tokenPayload);
+                }
+            }
+            else {
+                draft.common.otpVerificationStatus = {
+                    fetchState: 'Completed',
+                    error: undefined,
+                };
+                if (tokenPayload != null) {
+                    draft.common.token = (0, twoFactorAuthenticationPayload_1.toToken)(tokenPayload);
+                }
             }
-            draft.otpVerificationStatus = {
-                fetchState: 'Completed',
-                error: undefined,
-            };
         },
         verifyOtpFailure(draft, action) {
-            draft.otpVerificationStatus = {
-                fetchState: 'Error',
-                error: action.payload,
-            };
+            const { error, twoFASource, entityId } = action.payload;
+            if (twoFASource === 'CardUserOnboarding') {
+                draft.cardUserOnboarding.otpVerificationStatus = {
+                    fetchState: 'Error',
+                    error,
+                };
+            }
+            else if (twoFASource === 'ChargeCardHolder' && entityId != null) {
+                draft.chargeCardHolder[entityId] = Object.assign(Object.assign({}, draft.chargeCardHolder[entityId]), { otpVerificationStatus: {
+                        fetchState: 'Error',
+                        error,
+                    } });
+            }
+            else {
+                draft.common.otpVerificationStatus = {
+                    fetchState: 'Error',
+                    error,
+                };
+            }
         },
         clearTwoFactorAuthentication(draft) {
             Object.assign(draft, exports.initialState);

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationSelector.d.ts

@@ -1,12 +1,14 @@
-import { FetchStateAndError } from '../../commonStateTypes/common';
+import { FetchStateAndError, ID } from '../../commonStateTypes/common';
 import { View } from '../../commonStateTypes/viewAndReport/viewAndReport';
 import { RootState } from '../../reducer';
-import { CustomerToken } from './twoFactorAuthentication';
+import { Token, TwoFactorAuthentication, TwoFactorAuthenticationWithoutToken } from './twoFactorAuthentication';
 export interface TwoFactorAuthenticationView extends View {
     sendOtpStatus: FetchStateAndError;
     otpVerificationStatus: FetchStateAndError;
-    customerToken?: CustomerToken;
+    token?: Token;
     phone?: string;
     otpChallenge?: string;
 }
 export declare const getTwoFactorAuthenticationView: (state: RootState) => TwoFactorAuthenticationView;
+export declare const getTwoFactorAuthenticationViewForChargeCardHolder: (state: RootState, entityId: ID) => TwoFactorAuthentication;
+export declare const getTwoFactorAuthenticationViewForCardUserOnboarding: (state: RootState) => TwoFactorAuthenticationWithoutToken | undefined;

package/lib/view/twoFactorAuthentication/twoFactorAuthenticationSelector.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTwoFactorAuthenticationView = void 0;
+exports.getTwoFactorAuthenticationViewForCardUserOnboarding = exports.getTwoFactorAuthenticationViewForChargeCardHolder = exports.getTwoFactorAuthenticationView = void 0;
 const toolkit_1 = require("@reduxjs/toolkit");
+const twoFactorAuthentication_1 = require("./twoFactorAuthentication");
 exports.getTwoFactorAuthenticationView = (0, toolkit_1.createSelector)((state) => state.twoFactorAuthenticationState, (twoFAState) => {
-    return Object.assign({}, twoFAState);
+    return Object.assign({}, twoFAState.common);
+});
+exports.getTwoFactorAuthenticationViewForChargeCardHolder = (0, toolkit_1.createSelector)((state) => state.twoFactorAuthenticationState, (_state, entityId) => entityId, (twoFAState, entityId) => {
+    const twoFA = twoFAState.chargeCardHolder[entityId];
+    if (twoFA != null) {
+        return twoFA;
+    }
+    return twoFactorAuthentication_1.initialTwoFactorAuthentication;
+});
+exports.getTwoFactorAuthenticationViewForCardUserOnboarding = (0, toolkit_1.createSelector)((state) => state.twoFactorAuthenticationState, (twoFAState) => {
+    return twoFAState.cardUserOnboarding;
 });

package/lib/view/twoFactorAuthentication/verifyOtpEpic.d.ts

@@ -6,7 +6,10 @@ import { verifyOtpVendorView, verifyOtpVendorViewFailure, verifyOtpVendorViewSuc
 import { verifyOnboardingOfficerOtp, verifyOnboardingOfficerOtpFailure, verifyOnboardingOfficerOtpSuccess } from '../onboardingView/customerView/onboardingCustomerViewReducer';
 import { verifyOtpMyProfile, verifyOtpMyProfileFailure, verifyOtpMyProfileSuccess } from '../settingsView/settingsViewReducer';
 import { verifyOtpCardUserOnboarding, verifyOtpCardUserOnboardingFailure, verifyOtpCardUserOnboardingSuccess } from '../spendManagement/chargeCards/cardUserOnboarding/cardUserOnboardingReducer';
+import { verifyOtpCardHolderFailure } from '../spendManagement/chargeCards/chargeCardDetail/chargeCardDetailReducer';
+import { verifyOtpCardHolderSuccess } from '../spendManagement/chargeCards/chargeCardDetail/chargeCardDetailReducer';
+import { verifyOtpCardHolder } from '../spendManagement/chargeCards/chargeCardDetail/chargeCardDetailReducer';
 import { verifyOtpFailureSpendManagementSetUp, verifyOtpSpendManagementSetUp, verifyOtpSuccessSpendManagementSetUp } from '../spendManagement/commonSetup/setupViewReducer';
 import { verifyOtp, verifyOtpFailure, verifyOtpSuccess } from './twoFactorAuthenticationReducer';
-export type ActionType = ReturnType<typeof verifyOtp> | ReturnType<typeof verifyOtpSuccess> | ReturnType<typeof verifyOtpFailure> | ReturnType<typeof verifyOtpSpendManagementSetUp> | ReturnType<typeof verifyOtpSuccessSpendManagementSetUp> | ReturnType<typeof verifyOtpFailureSpendManagementSetUp> | ReturnType<typeof verifyOtpVendorView> | ReturnType<typeof verifyOtpVendorViewSuccess> | ReturnType<typeof verifyOtpVendorViewFailure> | ReturnType<typeof verifyOnboardingOfficerOtp> | ReturnType<typeof verifyOnboardingOfficerOtpSuccess> | ReturnType<typeof verifyOnboardingOfficerOtpFailure> | ReturnType<typeof verifyOtpCardUserOnboarding> | ReturnType<typeof verifyOtpCardUserOnboardingSuccess> | ReturnType<typeof verifyOtpCardUserOnboardingFailure> | ReturnType<typeof verifyOtpMyProfile> | ReturnType<typeof verifyOtpMyProfileFailure> | ReturnType<typeof verifyOtpMyProfileSuccess>;
-export declare const verifyOtpEpic: (actions$: ActionsObservable<ActionType>, _state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;
+export type ActionType = ReturnType<typeof verifyOtp> | ReturnType<typeof verifyOtpSuccess> | ReturnType<typeof verifyOtpFailure> | ReturnType<typeof verifyOtpSpendManagementSetUp> | ReturnType<typeof verifyOtpSuccessSpendManagementSetUp> | ReturnType<typeof verifyOtpFailureSpendManagementSetUp> | ReturnType<typeof verifyOtpVendorView> | ReturnType<typeof verifyOtpVendorViewSuccess> | ReturnType<typeof verifyOtpVendorViewFailure> | ReturnType<typeof verifyOnboardingOfficerOtp> | ReturnType<typeof verifyOnboardingOfficerOtpSuccess> | ReturnType<typeof verifyOnboardingOfficerOtpFailure> | ReturnType<typeof verifyOtpCardUserOnboarding> | ReturnType<typeof verifyOtpCardUserOnboardingSuccess> | ReturnType<typeof verifyOtpCardUserOnboardingFailure> | ReturnType<typeof verifyOtpMyProfile> | ReturnType<typeof verifyOtpMyProfileFailure> | ReturnType<typeof verifyOtpMyProfileSuccess> | ReturnType<typeof verifyOtpCardHolder> | ReturnType<typeof verifyOtpCardHolderSuccess> | ReturnType<typeof verifyOtpCardHolderFailure>;
+export declare const verifyOtpEpic: (actions$: ActionsObservable<ActionType>, state$: StateObservable<RootState>, zeniAPI: ZeniAPI) => Observable<ActionType>;