@zeniai/client-epic-state 5.0.92 → 5.0.93-beta0ND

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyChipIds.js

@@ -0,0 +1,19 @@
+// All chip-id producers MUST funnel through here — the picker's dedupe is content-blind
+// (`existing.id === option.id`), so vendors collapse on display name and MCC ids must
+// match the legacy convention saved templates use.
+export const VENDOR_CHIP_ID_PREFIX = 'vendor-';
+export const MCC_CHIP_ID_PREFIX = 'mcc-';
+export const buildVendorChipId = (name) => `${VENDOR_CHIP_ID_PREFIX}${name.trim().toLowerCase()}`;
+export const buildMccCategoryChipId = (name) => `${MCC_CHIP_ID_PREFIX}${name}`;
+export const toVendorChipFieldValue = (name, isSelected) => ({
+    id: buildVendorChipId(name),
+    label: name,
+    isSelected,
+});
+export const toMccCategoryChipFieldValue = (category, isSelected) => ({
+    id: buildMccCategoryChipId(category.name),
+    label: category.name,
+    isSelected,
+    optionalCode: category.mccCodes[0],
+    optionalCodes: [...category.mccCodes],
+});

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyFormDraftTypes.js

@@ -0,0 +1,6 @@
+export const CARD_POLICY_LIMIT_ROW_ID_TRANSACTION = 'transactionLimit';
+export const CARD_POLICY_LIMIT_ROW_ID_REQUIRE_RECEIPT = 'requireReceipt';
+export const toMccCategoryLike = (category) => ({
+    name: category.name,
+    mccCodes: category.mccCodes,
+});

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/cardPolicyRequestParts.js

@@ -0,0 +1,119 @@
+// Wire builders shared by manual and AI CFO drafts.
+// Inactive-side chips stay in form state for fast mode-flip but never go on the wire.
+export const collectMerchantNames = (field, forMode) => {
+    if (field.mode !== forMode) {
+        return [];
+    }
+    const items = forMode === 'allow' ? field.allowItems : field.blockItems;
+    return items.filter((item) => item.isSelected).map((item) => item.label);
+};
+// `optionalCodes` (plural) emits every code; falls back to the singular
+// `optionalCode`; chips with neither are dropped silently.
+export const collectCategoryCodes = (field, forMode) => {
+    if (field.mode !== forMode) {
+        return [];
+    }
+    const items = forMode === 'allow' ? field.allowItems : field.blockItems;
+    return items
+        .filter((item) => item.isSelected)
+        .flatMap((item) => {
+        if (item.optionalCodes != null && item.optionalCodes.length > 0) {
+            return item.optionalCodes;
+        }
+        return item.optionalCode != null ? [item.optionalCode] : [];
+    });
+};
+// `null` when the toggle is off (BE: "no threshold"); else `amount` (or 0).
+export const amountFromLimitRow = (limits, rowId) => {
+    const row = limits.find((entry) => entry.id === rowId);
+    if (row == null || !row.isEnabled) {
+        return null;
+    }
+    return row.amount ?? 0;
+};
+const REVIEW_GROUP_ID_ALLOWED_VENDORS = 'allowed-vendors';
+const REVIEW_GROUP_ID_BLOCKED_VENDORS = 'blocked-vendors';
+const REVIEW_GROUP_ID_ALLOWED_CATEGORIES = 'allowed-categories';
+const REVIEW_GROUP_ID_RESTRICTED_CATEGORIES = 'restricted-categories';
+const REVIEW_GROUP_ID_APPLIED_TO_CARDS = 'applied-to-cards';
+const REVIEW_GROUP_ID_LIMITS = 'limits';
+const REVIEW_LIMIT_CHIP_ID_TRANSACTION = 'limit-transaction';
+const REVIEW_LIMIT_CHIP_ID_RECEIPT = 'limit-receipt';
+const isChipOn = (chip) => chip.isSelected !== false;
+const findGroup = (row, groupId) => row.chipGroups.find((group) => group.id === groupId);
+const projectMerchantNamesFromGroup = (group) => group == null ? [] : group.chips.filter(isChipOn).map((chip) => chip.label);
+const projectCategoryCodesFromGroup = (group) => {
+    if (group == null) {
+        return [];
+    }
+    const codes = [];
+    for (const chip of group.chips) {
+        if (!isChipOn(chip)) {
+            continue;
+        }
+        if (chip.optionalCode != null && chip.optionalCode.length > 0) {
+            codes.push(chip.optionalCode);
+        }
+    }
+    return codes;
+};
+const projectApplyToCardsFromGroup = (group) => {
+    if (group == null) {
+        return [];
+    }
+    const cardIds = [];
+    for (const chip of group.chips) {
+        if (!isChipOn(chip)) {
+            continue;
+        }
+        if (chip.cardIds != null && chip.cardIds.length > 0) {
+            cardIds.push(...chip.cardIds);
+            continue;
+        }
+        cardIds.push(chip.id);
+    }
+    return cardIds;
+};
+const amountFromLimitsChip = (chip) => {
+    if (chip == null || chip.isSelected !== true) {
+        return null;
+    }
+    if (chip.optionalCode == null || chip.optionalCode.length === 0) {
+        return 0;
+    }
+    const parsed = Number(chip.optionalCode);
+    return Number.isFinite(parsed) ? parsed : 0;
+};
+// Used when `policyKind === "auto"`, where the row's chip groups are canonical
+// and source slices are empty.
+export const projectAutoReviewRowToCardPolicyRequestParts = (row) => {
+    const limitsGroup = findGroup(row, REVIEW_GROUP_ID_LIMITS);
+    const transactionChip = limitsGroup?.chips.find((chip) => chip.id === REVIEW_LIMIT_CHIP_ID_TRANSACTION);
+    const receiptChip = limitsGroup?.chips.find((chip) => chip.id === REVIEW_LIMIT_CHIP_ID_RECEIPT);
+    return {
+        allowedEntity: {
+            merchantNames: projectMerchantNamesFromGroup(findGroup(row, REVIEW_GROUP_ID_ALLOWED_VENDORS)),
+            categoryCodes: projectCategoryCodesFromGroup(findGroup(row, REVIEW_GROUP_ID_ALLOWED_CATEGORIES)),
+        },
+        blockedEntity: {
+            merchantNames: projectMerchantNamesFromGroup(findGroup(row, REVIEW_GROUP_ID_BLOCKED_VENDORS)),
+            categoryCodes: projectCategoryCodesFromGroup(findGroup(row, REVIEW_GROUP_ID_RESTRICTED_CATEGORIES)),
+        },
+        applyToCards: projectApplyToCardsFromGroup(findGroup(row, REVIEW_GROUP_ID_APPLIED_TO_CARDS)),
+        spendLimits: { transaction: amountFromLimitsChip(transactionChip) },
+        requiredReceiptThreshold: amountFromLimitsChip(receiptChip),
+    };
+};
+// Shared by both auto and bulk wire builders.
+export const REVIEW_GROUP_IDS = {
+    allowedVendors: REVIEW_GROUP_ID_ALLOWED_VENDORS,
+    blockedVendors: REVIEW_GROUP_ID_BLOCKED_VENDORS,
+    allowedCategories: REVIEW_GROUP_ID_ALLOWED_CATEGORIES,
+    restrictedCategories: REVIEW_GROUP_ID_RESTRICTED_CATEGORIES,
+    appliedToCards: REVIEW_GROUP_ID_APPLIED_TO_CARDS,
+    limits: REVIEW_GROUP_ID_LIMITS,
+};
+export const REVIEW_LIMIT_CHIP_IDS = {
+    transaction: REVIEW_LIMIT_CHIP_ID_TRANSACTION,
+    receipt: REVIEW_LIMIT_CHIP_ID_RECEIPT,
+};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyReducer.js

@@ -0,0 +1,154 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { applyAiCardPolicyFormDraftUpdate } from './applyAiCardPolicyFormDraftUpdate';
+import { applyExtractedPolicyToAiCardPolicyDraft as applyExtractedToAiDraftHelper } from './applyExtractedPolicyToAiCardPolicyDraft';
+import { applyExtractedPolicyToManualCardPolicyDraft as applyExtractedToManualDraftHelper } from './applyExtractedPolicyToManualCardPolicyDraft';
+import { applyUploadPlanToAiCardPolicyDraft as applyUploadPlanToAiDraftHelper } from './applyUploadPlanToAiCardPolicyDraft';
+import { buildAiCardPolicyFormDraftSeed } from './buildAiCardPolicyFormDraftSeed';
+import { buildManualCardPolicyFormDraftSeed, } from './buildManualCardPolicyFormDraftSeed';
+import { toMccCategoryLike, } from './cardPolicyFormDraftTypes';
+export const initialState = {
+    createCardPolicyTemplateRequestState: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
+    lastCreatedCardPolicyTemplateIds: [],
+    lastCreateCardPolicyTemplateErrors: [],
+};
+const createCardPolicy = createSlice({
+    name: 'createCardPolicy',
+    initialState,
+    reducers: {
+        createCardPolicyTemplates: {
+            reducer(draft, action) {
+                draft.createCardPolicyTemplateRequestState.fetchState = 'In-Progress';
+                draft.createCardPolicyTemplateRequestState.error = undefined;
+                draft.lastCreatedCardPolicyTemplateIds = [];
+                draft.lastCreateCardPolicyTemplateErrors = [];
+                // Lets list/drawer attribute the in-flight create to its AI CFO session.
+                draft.lastCreateCardPolicySourceChatSessionId =
+                    action.payload.sourceChatSessionId;
+            },
+            prepare(request) {
+                return { payload: request };
+            },
+        },
+        updateCreateCardPolicyTemplateRequestState(draft, action) {
+            draft.createCardPolicyTemplateRequestState.fetchState =
+                action.payload.fetchState;
+            draft.createCardPolicyTemplateRequestState.error = action.payload.error;
+            if (action.payload.templateIds != null) {
+                draft.lastCreatedCardPolicyTemplateIds = action.payload.templateIds;
+            }
+            if (action.payload.perItemErrors != null) {
+                draft.lastCreateCardPolicyTemplateErrors = action.payload.perItemErrors;
+            }
+        },
+        // Dispatched by `seedAiCardPolicyFormDraftEpic` when the AI answer lands.
+        seedAiCardPolicyFormDraft: {
+            reducer(draft, action) {
+                const { draft: nextDraft, context } = buildAiCardPolicyFormDraftSeed({
+                    initialData: action.payload.initialData,
+                    cardsMasterList: action.payload.cardsMasterList,
+                    categorySearchOptions: action.payload.mccCategories.map(toMccCategoryLike),
+                    suggestedAllowMerchants: action.payload.suggestedAllowMerchants,
+                    suggestedBlockMerchants: action.payload.suggestedBlockMerchants,
+                    suggestedAllowCategories: (action.payload.suggestedAllowCategories ?? []).map(toMccCategoryLike),
+                    suggestedBlockCategories: (action.payload.suggestedBlockCategories ?? []).map(toMccCategoryLike),
+                });
+                draft.aiCardPolicyFormDraft = nextDraft;
+                draft.aiCardPolicyFormDraftContext = context;
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        // Per-mode behavior lives in `applyAiCardPolicyFormDraftUpdate`.
+        updateAiCardPolicyFormDraft(draft, action) {
+            draft.aiCardPolicyFormDraft = applyAiCardPolicyFormDraftUpdate({
+                prev: draft.aiCardPolicyFormDraft,
+                next: action.payload,
+                context: draft.aiCardPolicyFormDraftContext,
+            });
+        },
+        // No-op when the draft isn't in `upload` mode.
+        updateAiCardPolicyFormDraftFromUploadPlan: {
+            reducer(draft, action) {
+                if (draft.aiCardPolicyFormDraft == null ||
+                    draft.aiCardPolicyFormDraftContext == null) {
+                    return;
+                }
+                const { draft: nextDraft, context } = applyUploadPlanToAiDraftHelper({
+                    current: draft.aiCardPolicyFormDraft,
+                    context: draft.aiCardPolicyFormDraftContext,
+                    wizardPlan: action.payload.wizardPlan,
+                    source: action.payload.source,
+                });
+                draft.aiCardPolicyFormDraft = nextDraft;
+                draft.aiCardPolicyFormDraftContext = context;
+            },
+            prepare(wizardPlan, source) {
+                return { payload: { wizardPlan, source } };
+            },
+        },
+        // Dispatched by the extract-success bridge when the upload originated from
+        // inside an AI CFO card-policy form.
+        applyExtractedPolicyToAiCardPolicyDraft: {
+            reducer(draft, action) {
+                if (draft.aiCardPolicyFormDraft == null) {
+                    return;
+                }
+                draft.aiCardPolicyFormDraft = applyExtractedToAiDraftHelper({
+                    current: draft.aiCardPolicyFormDraft,
+                    extracted: action.payload.extracted,
+                    vendorSearchOptions: action.payload.vendorSearchOptions,
+                    categorySearchOptions: action.payload.categorySearchOptions,
+                });
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        clearAiCardPolicyFormDraft(draft) {
+            draft.aiCardPolicyFormDraft = undefined;
+            draft.aiCardPolicyFormDraftContext = undefined;
+        },
+        // Dispatched on the manual create-page mount.
+        seedManualCardPolicyFormDraft: {
+            reducer(draft, action) {
+                draft.manualCardPolicyFormDraft = buildManualCardPolicyFormDraftSeed(action.payload);
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        updateManualCardPolicyFormDraft(draft, action) {
+            draft.manualCardPolicyFormDraft = action.payload;
+        },
+        // Dispatched by the extract-success bridge when the upload originated from
+        // the manual `CardPolicyCreatePage`.
+        applyExtractedPolicyToManualCardPolicyDraft: {
+            reducer(draft, action) {
+                if (draft.manualCardPolicyFormDraft == null) {
+                    return;
+                }
+                draft.manualCardPolicyFormDraft = applyExtractedToManualDraftHelper({
+                    current: draft.manualCardPolicyFormDraft,
+                    extracted: action.payload.extracted,
+                    vendorSearchOptions: action.payload.vendorSearchOptions,
+                    categorySearchOptions: action.payload.categorySearchOptions,
+                });
+            },
+            prepare(payload) {
+                return { payload };
+            },
+        },
+        clearManualCardPolicyFormDraft(draft) {
+            draft.manualCardPolicyFormDraft = undefined;
+        },
+        clearCreateCardPolicy(draft) {
+            Object.assign(draft, initialState);
+        },
+    },
+});
+export const { createCardPolicyTemplates, updateCreateCardPolicyTemplateRequestState, seedAiCardPolicyFormDraft, updateAiCardPolicyFormDraft, updateAiCardPolicyFormDraftFromUploadPlan, applyExtractedPolicyToAiCardPolicyDraft, clearAiCardPolicyFormDraft, seedManualCardPolicyFormDraft, updateManualCardPolicyFormDraft, applyExtractedPolicyToManualCardPolicyDraft, clearManualCardPolicyFormDraft, clearCreateCardPolicy, } = createCardPolicy.actions;
+export default createCardPolicy.reducer;

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicySelector.js

@@ -0,0 +1,22 @@
+export function getCreateCardPolicyTemplateRequestState(state) {
+    return state.createCardPolicyTemplateRequestState;
+}
+export function getLastCreatedCardPolicyTemplateIds(state) {
+    return state.lastCreatedCardPolicyTemplateIds;
+}
+// First id; single-create pages use this for navigate-to-detail.
+export function getLastCreatedCardPolicyTemplateId(state) {
+    return state.lastCreatedCardPolicyTemplateIds[0];
+}
+export function getLastCreateCardPolicyTemplateErrors(state) {
+    return state.lastCreateCardPolicyTemplateErrors;
+}
+export function getLastCreateCardPolicySourceChatSessionId(state) {
+    return state.lastCreateCardPolicySourceChatSessionId;
+}
+export function getAiCardPolicyFormDraft(state) {
+    return state.aiCardPolicyFormDraft;
+}
+export function getManualCardPolicyFormDraft(state) {
+    return state.manualCardPolicyFormDraft;
+}

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyState.js

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

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/createCardPolicyTemplateEpic.js

@@ -0,0 +1,39 @@
+import { from, of } from 'rxjs';
+import { catchError, filter, mergeMap } from 'rxjs/operators';
+import { updateCreatedCardPolicyTemplate } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { toBulkCreateCardPolicyTemplateError, toCreateCardPolicyTemplatesRequestBody, } from '../../../../../entity/cardPolicy/cardPolicyPayload';
+import { createZeniAPIStatus, isSuccessStatus } from '../../../../../responsePayload';
+import { createCardPolicyTemplates, updateCreateCardPolicyTemplateRequestState, } from './createCardPolicyReducer';
+// `POST /cards/1.0/policy-templates` (bulk). On success fans entity hydrations
+// + a single state update with ids + per-item errors. Partial success is
+// `Completed`; the UI inspects the slice's per-item errors for partial-success UX.
+export const createCardPolicyTemplatesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(createCardPolicyTemplates.match), mergeMap((action) => {
+    const body = toCreateCardPolicyTemplatesRequestBody(action.payload);
+    return zeniAPI
+        .postAndGetJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/policy-templates`, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            const { templates_created, errors } = response.data;
+            const createdTemplates = templates_created.map((row) => row.template);
+            const actions = [
+                ...createdTemplates.map((template) => updateCreatedCardPolicyTemplate(template)),
+                updateCreateCardPolicyTemplateRequestState({
+                    fetchState: 'Completed',
+                    perItemErrors: (errors ?? []).map(toBulkCreateCardPolicyTemplateError),
+                    templateIds: createdTemplates.map((template) => template.template_id),
+                }),
+            ];
+            return from(actions);
+        }
+        else {
+            return of(updateCreateCardPolicyTemplateRequestState({
+                fetchState: 'Error',
+                error: response.status,
+            }));
+        }
+    }), catchError((error) => of(updateCreateCardPolicyTemplateRequestState({
+        fetchState: 'Error',
+        error: createZeniAPIStatus('Unexpected Error', 'Create card-policy templates REST API call errored out' +
+            JSON.stringify(error)),
+    }))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/deriveAiPolicyReviewRowsFromInputs.js

@@ -0,0 +1,140 @@
+// Composes Step 5 review rows from live Step 1–4 form state. Per-row `isChecked`
+// and per-chip `isSelected` are merged from `prevPoliciesReview` so user-removed
+// chips don't snap back when an upstream slice changes.
+export const deriveAiPolicyReviewRowsFromInputs = ({ vendorPolicy, categoryPolicy, cardSelections, limits, suggestedPoliciesSeed, prevPoliciesReview, }) => {
+    const prevById = new Map(prevPoliciesReview.map((row) => [row.id, row]));
+    const groups = deriveSharedChipGroups({
+        vendorPolicy,
+        categoryPolicy,
+        cardSelections,
+        limits,
+    });
+    return suggestedPoliciesSeed.map((seed) => {
+        const previous = prevById.get(seed.id);
+        return {
+            id: seed.id,
+            name: seed.name,
+            isChecked: previous?.isChecked ?? seed.isChecked,
+            chipGroups: previous != null
+                ? mergeChipSelections(groups, previous.chipGroups)
+                : groups,
+        };
+    });
+};
+const mergeChipSelections = (next, prev) => {
+    const prevByGroupId = new Map(prev.map((group) => [group.id, group]));
+    return next.map((group) => {
+        const prevGroup = prevByGroupId.get(group.id);
+        if (prevGroup == null) {
+            return group;
+        }
+        const prevSelectedById = new Map(prevGroup.chips.map((chip) => [chip.id, chip.isSelected]));
+        return {
+            ...group,
+            chips: group.chips.map((chip) => {
+                const prevSelected = prevSelectedById.get(chip.id);
+                return prevSelected === undefined
+                    ? chip
+                    : { ...chip, isSelected: prevSelected };
+            }),
+        };
+    });
+};
+const deriveSharedChipGroups = ({ vendorPolicy, categoryPolicy, cardSelections, limits, }) => {
+    const groups = [];
+    const vendorChips = chipsFromAllowBlock(vendorPolicy);
+    if (vendorChips.length > 0) {
+        groups.push({
+            id: 'vendors',
+            label: vendorPolicy.mode === 'allow' ? 'Allowed vendors' : 'Blocked vendors',
+            chips: vendorChips,
+        });
+    }
+    const categoryChips = chipsFromAllowBlock(categoryPolicy);
+    if (categoryChips.length > 0) {
+        groups.push({
+            id: 'categories',
+            label: categoryPolicy.mode === 'allow'
+                ? 'Allowed categories'
+                : 'Blocked categories',
+            chips: categoryChips,
+        });
+    }
+    const cardChips = cardSelections
+        .filter((row) => row.isChecked)
+        .map((row) => ({
+        id: row.id,
+        label: row.owner.displayName,
+        chipKind: 'avatar',
+    }));
+    if (cardChips.length > 0) {
+        groups.push({ id: 'cardholders', label: 'Cardholders', chips: cardChips });
+    }
+    const limitChips = limits.map((row) => ({
+        id: limitChipIdForRowId(row.id),
+        label: limitDisplayLabelForRowId(row.id),
+        helperText: limitHelperTextForRowId(row.id),
+        placeholder: '$0',
+        chipKind: 'positive',
+        isSelected: row.isEnabled,
+        optionalCode: row.isEnabled && row.amount != null ? String(row.amount) : undefined,
+    }));
+    if (limitChips.length > 0) {
+        groups.push({
+            id: 'limits',
+            label: 'Limits',
+            kind: 'limits',
+            chips: limitChips,
+        });
+    }
+    return groups;
+};
+const chipsFromAllowBlock = (field) => {
+    const items = field.mode === 'allow' ? field.allowItems : field.blockItems;
+    return items
+        .filter((item) => item.isSelected)
+        .map((item) => ({
+        id: item.id,
+        label: item.optionalCode != null
+            ? `${item.label} (${item.optionalCode})`
+            : item.label,
+        chipKind: field.mode === 'allow' ? 'positive' : 'negative',
+    }));
+};
+const limitChipIdForRowId = (rowId) => {
+    if (rowId === 'transactionLimit') {
+        return 'limit-transaction';
+    }
+    if (rowId === 'requireReceipt') {
+        return 'limit-receipt';
+    }
+    return rowId;
+};
+const limitDisplayLabelForRowId = (rowId) => {
+    if (rowId === 'transactionLimit') {
+        return 'Transaction Limit';
+    }
+    if (rowId === 'requireReceipt') {
+        return 'Require Receipt';
+    }
+    return humanizeLimitId(rowId);
+};
+const limitHelperTextForRowId = (rowId) => {
+    if (rowId === 'transactionLimit') {
+        return 'Maximum amount per single transaction';
+    }
+    if (rowId === 'requireReceipt') {
+        return 'Require a receipt above this amount';
+    }
+    return undefined;
+};
+const humanizeLimitId = (id) => {
+    const spaced = id
+        .replace(/([A-Z])/g, ' $1')
+        .replace(/[_-]+/g, ' ')
+        .trim();
+    if (spaced.length === 0) {
+        return id;
+    }
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1).toLowerCase();
+};

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/fetchCardPolicyMccCategoriesEpic.js

@@ -0,0 +1,20 @@
+import { from, of } from 'rxjs';
+import { catchError, exhaustMap, filter, mergeMap } from 'rxjs/operators';
+import { fetchCardPolicyMccCategories, updateCardPolicyMccCategories, updateCardPolicyMccCategoriesFailure, } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { createZeniAPIStatus, isSuccessStatus, } from '../../../../../responsePayload';
+export const fetchCardPolicyMccCategoriesEpic = (actions$, _state$, zeniAPI) => actions$.pipe(filter(fetchCardPolicyMccCategories.match), 
+// `exhaustMap` dedupes the React 18 StrictMode double-mount fetch on
+// both Create and Edit screens, which would otherwise yield two HTTP calls.
+exhaustMap(() => {
+    return zeniAPI
+        .getJSON(`${zeniAPI.apiEndPoints.cardMicroServiceBaseUrl}/1.0/cards/mcc-codes`)
+        .pipe(mergeMap((response) => {
+        if (isSuccessStatus(response) && response.data != null) {
+            return from([updateCardPolicyMccCategories(response.data)]);
+        }
+        else {
+            return of(updateCardPolicyMccCategoriesFailure(response.status));
+        }
+    }), catchError((error) => of(updateCardPolicyMccCategoriesFailure(createZeniAPIStatus('Unexpected Error', 'Fetch card policy MCC categories REST API call errored out' +
+        JSON.stringify(error))))));
+}));

package/lib/esm/view/spendManagement/chargeCards/cardPolicy/createCardPolicy/seedAiCardPolicyFormDraftEpic.js

@@ -0,0 +1,100 @@
+import { EMPTY, concat, of } from 'rxjs';
+import { distinctUntilChanged, filter, map, mergeMap, take, } from 'rxjs/operators';
+import { upsertAnswerPayload, upsertOrAddQuestionAnswerPayload, } from '../../../../../entity/aiCfo/aiCfoReducer';
+import { getQuestionAnswerByIdForChatSession } from '../../../../../entity/aiCfo/aiCfoSelector';
+import { fetchCardPolicyMccCategories } from '../../../../../entity/cardPolicy/cardPolicyReducer';
+import { getAllChargeCardsWithUser } from '../../chargeCardList/chargeCardListSelector';
+import { clearAiCardPolicyFormDraft, seedAiCardPolicyFormDraft, updateCreateCardPolicyTemplateRequestState, } from './createCardPolicyReducer';
+const isClosedChargeCardStatusCode = (code) => code === 'closed' || code === 'closed_by_customer';
+const toCardPolicyCardSelectionRow = (card) => {
+    const user = card.cardHolderUser;
+    const displayName = `${user.firstName ?? ''} ${user.lastName ?? ''}`.trim() ||
+        user.email ||
+        user.userId;
+    return {
+        id: card.id,
+        isChecked: false,
+        cardName: card.cardName,
+        last4: card.accountLast4,
+        limitAmount: card.limit?.amount ?? 0,
+        limitCadence: card.creditLimitFrequency?.code,
+        owner: {
+            userId: user.userId,
+            displayName,
+            roleLabel: card.cardHolderRoles?.titleAtCompany,
+        },
+        utilizationAmount: (card.limit?.amount ?? 0) - (card.available?.amount ?? 0),
+    };
+};
+const readCardsMasterList = (state) => {
+    const view = getAllChargeCardsWithUser(state);
+    return view.cards
+        .filter((card) => !isClosedChargeCardStatusCode(card.status?.code))
+        .map(toCardPolicyCardSelectionRow);
+};
+const readMccCategoriesAvailable = (state) => state.cardPolicyState.mccCategoriesFetchState === 'Completed';
+const readCardPolicyPayload = (state, chatSessionId, questionAnswerId) => {
+    const qa = getQuestionAnswerByIdForChatSession(state.aiCfoState, chatSessionId, questionAnswerId);
+    const visualization = qa?.responses.answer?.content.visualization;
+    if (visualization?.type !== 'interactive_form') {
+        return undefined;
+    }
+    const data = visualization.data;
+    if (!('formType' in data) || data.formType !== 'card_policy') {
+        return undefined;
+    }
+    return data.payload;
+};
+const resolveQuestionAnswerId = (state, action) => {
+    if (action.payload.questionAnswerId != null) {
+        return action.payload.questionAnswerId;
+    }
+    const session = state.aiCfoState.aiCfoByChatSessionId[action.payload.chatSessionId];
+    return session?.questionAnswers.slice(-1)[0]?.questionAnswerId;
+};
+const isSeedTrigger = (action) => upsertAnswerPayload.match(action) ||
+    upsertOrAddQuestionAnswerPayload.match(action);
+const isCreateSuccess = (action) => updateCreateCardPolicyTemplateRequestState.match(action) &&
+    action.payload.fetchState === 'Completed';
+const buildSeedAction = (state, payload) => {
+    const cardsMasterList = readCardsMasterList(state);
+    const mccCategories = state.cardPolicyState.mccCategories;
+    return seedAiCardPolicyFormDraft({
+        initialData: payload,
+        cardsMasterList,
+        mccCategories,
+        suggestedAllowMerchants: state.cardPolicyState.suggestedAllowMerchants,
+        suggestedBlockMerchants: state.cardPolicyState.suggestedBlockMerchants,
+        suggestedAllowCategories: state.cardPolicyState.suggestedAllowCategories,
+        suggestedBlockCategories: state.cardPolicyState.suggestedBlockCategories,
+    });
+};
+// Seeds the AI card-policy draft from `interactive_form` answers with
+// `formType === "card_policy"`, clearing on bulk-create success. Defers seeding
+// until MCC categories load so category chips can resolve to human labels.
+export const seedAiCardPolicyFormDraftEpic = (actions$, state$) => actions$.pipe(mergeMap((action) => {
+    if (isCreateSuccess(action)) {
+        return of(clearAiCardPolicyFormDraft());
+    }
+    if (!isSeedTrigger(action)) {
+        return EMPTY;
+    }
+    const state = state$.value;
+    const questionAnswerId = resolveQuestionAnswerId(state, action);
+    if (questionAnswerId == null) {
+        return EMPTY;
+    }
+    const payload = readCardPolicyPayload(state, action.payload.chatSessionId, questionAnswerId);
+    if (payload == null) {
+        return EMPTY;
+    }
+    if (readMccCategoriesAvailable(state)) {
+        return of(buildSeedAction(state, payload));
+    }
+    const seedWhenMccLoaded$ = state$.pipe(map((rs) => readMccCategoriesAvailable(rs)), distinctUntilChanged(), filter((available) => available), take(1), map(() => buildSeedAction(state$.value, payload)));
+    const mccFetchState = state.cardPolicyState.mccCategoriesFetchState;
+    if (mccFetchState === 'In-Progress') {
+        return seedWhenMccLoaded$;
+    }
+    return concat(of(fetchCardPolicyMccCategories()), seedWhenMccLoaded$);
+}));