@capillarytech/creatives-library 9.0.54-alpha.3 → 9.0.54

package/constants/unified.js

@@ -63,6 +63,7 @@ export const ENABLE_AI_SUGGESTIONS = 'ENABLE_AI_SUGGESTIONS';
 export const AI_CONTENT_BOT_DISABLED = 'AI_CONTENT_BOT_DISABLED';
 export const AI_DOCUMENTATION_BOT_ENABLED = 'AI_DOCUMENTATION_BOT_ENABLED';
 export const ENABLE_PRODUCT_SUPPORT_VIDEOS = 'ENABLE_PRODUCT_SUPPORT_VIDEOS';
+export const SUPPORT_ENGAGEMENT_MODULE = 'SUPPORT_ENGAGEMENT_MODULE';
 export const EMBEDDED = 'embedded';
 // --- Tag/Validation Constants ---
 export const CARD_RELATED_TAGS = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "9.0.54-alpha.3",
+  "version": "9.0.54",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/services/api.js

@@ -701,15 +701,6 @@ export const createCentralCommsMetaId = (payload, metaType = TRANSACTION) => {
   return request(url, getAPICallObject('POST', payload, false, false, false, true));
 };
 
-// CCS CommDefinition API (new Veyron /api/v1/commdefinition surface, proxied
-// through cap-creatives-api's /comm-definitions). Used by CommunicationFlow's
-// own Save action — separate from the legacy messageMeta functions above,
-// which remain in use by CreativesContainer's own save flow (Cap/sagas.js).
-export const createCommDefinition = (payload) => {
-  const url = `${API_ENDPOINT}/comm-definitions`;
-  return request(url, getAPICallObject('POST', payload, false, false, false, true));
-};
-
 export const getCentralCommsMetaIds = (metaIds, metaType = TRANSACTION) => {
   const url = `${API_ENDPOINT}/common/central-comms/meta-id/${metaType}?metaIds=${metaIds}`;
   return request(url, getAPICallObject('GET', null, false, false, false, true));

package/utils/common.js

@@ -99,6 +99,10 @@ export const hasSupportCKEditor = Auth.hasFeatureAccess.bind(
   null,
   SUPPORT_CK_EDITOR,
 );
+export const hasSupportEngagementModule = Auth.hasFeatureAccess.bind(
+  null,
+  SUPPORT_ENGAGEMENT_MODULE,
+);
 
 export const hasGiftVoucherFeature = Auth.hasFeatureAccess.bind(
   null,

package/v2Components/FormBuilder/Classic.js

@@ -4276,13 +4276,13 @@ class FormBuilder extends React.Component { // eslint-disable-line react/prefer-
               forceRender: true,
               tab: (
                 <div className="form-tab-header" onInput={(e) => e.stopPropagation()}>
-                  { this.state.translationLang !== 'ja-JP' && (
+                  {
                   _.forEach(renderedContentSections, (value) => {
                     if (value) {
                       return value;
                     }
                     return value;
-                  }))
+                  })
                   }
                 </div>
               ),

package/v2Containers/CommunicationFlow/CommunicationFlow.js

@@ -17,11 +17,10 @@ import { createStructuredSelector } from 'reselect';
 import CapRow from '@capillarytech/cap-ui-library/CapRow';
 import CapDivider from '@capillarytech/cap-ui-library/CapDivider';
 import CapButton from '@capillarytech/cap-ui-library/CapButton';
-import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
 // import injectSaga from '../../utils/injectSaga';   // cap-coupons flows disabled
 // import injectReducer from '../../utils/injectReducer';
 import { makeSelectAuthenticated } from '../Cap/selectors';
-import { createCommDefinition } from '../../services/api';
+import { createCentralCommsMetaId, getCentralCommsMetaIds } from '../../services/api';
 import DynamicControlsStep from './steps/DynamicControlsStep';
 import MessageTypeStep from './steps/MessageTypeStep';
 import CommunicationStrategyStep from './steps/CommunicationStrategyStep';
@@ -36,11 +35,9 @@ import {
   CHANNELS,
   INCENTIVE_TYPES,
   DYNAMIC_CONTROLS_CONFIG,
-  CCS_STRATEGY_TYPE_SINGLE,
-  CCS_CHANNEL_CONTENT_KEY_MAP,
-  CCS_CHANNEL_DELIVERY_KEY_MAP,
-  CCS_CHANNEL_NAME_MAP,
-  CCS_CONTENT_TRANSFORMS,
+  CHANNEL_CONTENT_KEY_MAP,
+  CHANNEL_DELIVERY_KEY_MAP,
+  CAMPAIGNS,
 } from './constants';
 import { getEnabledSteps } from './utils/getEnabledSteps';
 import messages from './messages';
@@ -67,25 +64,6 @@ const hasDeliverySettingForChannel = (channelSetting, channel) => {
   return !!settings && Object.values(settings).some((v) => v !== null && v !== '' && v !== undefined);
 };
 
-// createCommDefinition resolves (rather than rejects) with the CCS error envelope
-// for 4xx/5xx responses — see api.js's request()/checkStatus. A duplicate
-// referenceId within the org comes back as this specific 409.
-const isDuplicateReferenceIdError = (res) => res?.success === false && res?.status?.message === 'REFERENCE_ID_EXISTS';
-
-/**
- * CCS requires referenceId on create; the consumer-supplied Alert/comm name is
- * mandatory but referenceId is optional in every consumer's own form. Generate
- * a stable fallback from the name rather than failing the save.
- */
-const buildCcsReferenceId = (name) => {
-  const slug = (name || 'COMM')
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '') || 'COMM';
-  return `${slug}_${Date.now()}`;
-};
-
 const CommunicationFlow = ({
   config,
   initialData,
@@ -113,7 +91,6 @@ const CommunicationFlow = ({
     };
   });
   const [validationErrors, setValidationErrors] = useState({});
-  const [saveError, setSaveError] = useState(null);
 
   // Memoize enabled steps
   const enabledSteps = useMemo(() => getEnabledSteps(config), [config]);
@@ -173,88 +150,74 @@ const CommunicationFlow = ({
   }, []);
 
   const handleSave = useCallback(async () => {
-    setSaveError(null);
     const aggregatedData = getAggregatedData();
     const shouldUseCCS = config?.useCCS !== false;
-    let ccsCommDefinition = null;
 
     if (shouldUseCCS) {
-      const isMultiChannel = [CHANNEL_PRIORITY, AB_TEST].includes(aggregatedData.communicationStrategy);
-      const contentItem = (aggregatedData.contentItems || [])[0];
-      // Consumer-supplied name (e.g. CapNotify's Alert Name field) — CommunicationFlow
-      // has no name input of its own, so this is mandatory input from config.context.
-      const name = config?.context?.name;
+      const ouId = config?.context?.ouId || -1;
+      const module = config?.context?.module
+        || (config?.consumer ? config.consumer.toUpperCase() : CAMPAIGNS);
 
-      // CCS create is SINGLE-strategy only this phase (D1); CHANNEL_PRIORITY/AB_TEST
-      // carry multiple content items with no CCS equivalent yet.
-      if (!isMultiChannel && contentItem && name) {
-        const rawChannel = (contentItem.channel || '').toUpperCase();
-        const channel = CCS_CHANNEL_NAME_MAP[rawChannel] || rawChannel;
-        const contentKey = CCS_CHANNEL_CONTENT_KEY_MAP[channel];
-        const deliveryKey = CCS_CHANNEL_DELIVERY_KEY_MAP[channel];
-        const contentTransform = CCS_CONTENT_TRANSFORMS[channel];
-        const contentPayload = contentTransform ? contentTransform(contentItem.templateData) : contentItem.templateData;
-        const { dynamicControls = {} } = aggregatedData;
-        const channelSettings = aggregatedData.deliverySetting?.channelSetting?.[channel] || {};
-        const referenceId = config?.context?.referenceId || buildCcsReferenceId(name);
+      const channelContentKeyMap = CHANNEL_CONTENT_KEY_MAP;
+      const channelDeliveryKeyMap = CHANNEL_DELIVERY_KEY_MAP;
 
-        const payload = {
-          referenceId,
-          name,
-          description: config?.context?.description || undefined,
-          strategyType: CCS_STRATEGY_TYPE_SINGLE,
-          settings: {
-            additionalSettings: {
-              useTinyUrl: dynamicControls.useTinyUrl ?? false,
-              encryptUrl: dynamicControls.sendToControlCustomers ?? false,
-              linkTrackingEnabled: dynamicControls.overrideDailyLimit ?? false,
-              userSubscriptionDisabled: dynamicControls.sendToBrandPocs ?? false,
-            },
-            executionParams: {},
-          },
-          singleChannelStrategy: {
-            variant: {
-              channel,
-              // `channel` spreads LAST in both objects below — contentItem.templateData
-              // (e.g. mobile push) carries the UI's own internal channel identifier
-              // (MOBILEPUSH), which must never win over CCS's normalized enum value
-              // (PUSH) once spread order puts it after.
-              ...(contentKey && { [contentKey]: { ...contentPayload, channel } }),
-              ...(deliveryKey && { [deliveryKey]: { channelSettings: { ...channelSettings, channel } } }),
-            },
-          },
-        };
+      const contentItems = aggregatedData.contentItems || [];
+      const { dynamicControls = {} } = aggregatedData;
 
+      const additionalSettings = {
+        useTinyUrl: dynamicControls.useTinyUrl ?? false,
+        encryptUrl: dynamicControls.sendToControlCustomers ?? false,
+        linkTrackingEnabled: dynamicControls.overrideDailyLimit ?? false,
+        userSubscriptionDisabled: dynamicControls.sendToBrandPocs ?? false,
+      };
+
+      if (contentItems.length > 0) {
         try {
-          const res = await createCommDefinition(payload);
-          if (isDuplicateReferenceIdError(res)) {
-            // Duplicate referenceId in this org — block the save so the user can
-            // change it, rather than silently proceeding without a CCS comm.
-            setSaveError(formatMessage(messages.duplicateReferenceIdError));
-            return;
-          }
-          const data = res?.response?.data;
-          if (data?.id) {
-            ccsCommDefinition = {
-              id: data.id,
-              referenceId: data.referenceId,
-              version: data.version?.version ?? 1,
-              status: data.status,
-            };
+          const responses = await Promise.all(
+            contentItems.map((item) => {
+              const channel = (item.channel || '').toUpperCase();
+              const contentKey = channelContentKeyMap[channel];
+              const deliveryKey = channelDeliveryKeyMap[channel];
+              const payload = {
+                centralCommsPayload: {
+                  ouId,
+                  channel,
+                  module,
+                  executionParams: {},
+                  clientName: 'EMF',
+                  ...(contentKey && {
+                    [contentKey]: { channel, ...item.templateData },
+                  }),
+                  ...(deliveryKey && {
+                    [deliveryKey]: {
+                      additionalSettings,
+                      channelSettings: {
+                        channel,
+                        ...(aggregatedData.deliverySetting?.channelSetting?.[channel] || {}),
+                      },
+                    },
+                  }),
+                },
+              };
+              return createCentralCommsMetaId(payload);
+            }),
+          );
+
+          const metaIds = responses
+            .map((res) => res?.response?.data?.id)
+            .filter(Boolean)
+            .join(',');
+
+          if (metaIds) {
+            const getResponse = await getCentralCommsMetaIds(metaIds);
           }
         } catch (error) {
-          console.error('[CommunicationFlow] CCS createCommDefinition error:', error);
+          console.error('[CommunicationFlow] CCS createCentralCommsMetaId error:', error);
         }
-      } else if (!name) {
-        console.warn('[CommunicationFlow] Skipping CCS createCommDefinition — config.context.name is required');
-      } else if (isMultiChannel) {
-        console.warn('[CommunicationFlow] Skipping CCS createCommDefinition — CHANNEL_PRIORITY/AB_TEST strategies are not supported by CCS create yet (SINGLE only)');
-      } else if (!contentItem) {
-        console.warn('[CommunicationFlow] Skipping CCS createCommDefinition — no content item found (contentItems is empty)');
       }
     }
 
-    onSave(ccsCommDefinition ? { ...aggregatedData, ccsCommDefinition } : aggregatedData);
+    onSave(aggregatedData);
   }, [getAggregatedData, config, onSave]);
 
   // Call onChange callback when stepData changes
@@ -354,11 +317,6 @@ const CommunicationFlow = ({
       {renderSteps()}
       {onSave && (
         <CapRow useLegacy className="communication-flow-container__footer">
-          {saveError && (
-            <CapLabel type="label2" className="communication-flow-container__save-error">
-              {saveError}
-            </CapLabel>
-          )}
           <CapButton type="primary" onClick={handleSave} disabled={isSaveDisabled}>
             {formatMessage(messages.save)}
           </CapButton>

package/v2Containers/CommunicationFlow/CommunicationFlowCard.js

@@ -19,7 +19,6 @@ import CapIcon from '@capillarytech/cap-ui-library/CapIcon';
 import CapLabel from '@capillarytech/cap-ui-library/CapLabel';
 import CapHeader from '@capillarytech/cap-ui-library/CapHeader';
 import CapSlideBox from '@capillarytech/cap-ui-library/CapSlideBox';
-import CapTooltip from '@capillarytech/cap-ui-library/CapTooltip';
 import CommunicationFlow from './index';
 import { CHANNELS, DEFAULT_COMMUNICATION_STRATEGY_OPTIONS, DYNAMIC_CONTROLS_CONFIG } from './constants';
 import {
@@ -42,7 +41,7 @@ const resolveValue = (val) => {
 
 const SENDER_ID_RESOLVERS = {
   [SMS]: (setting) => resolveValue(setting?.gsmSenderId),
-  [EMAIL]: (setting) => resolveValue(setting?.senderId),
+  [EMAIL]: (setting) => resolveValue(setting?.senderEmail),
   [VIBER]: (setting) => resolveValue(setting?.sender) || resolveValue(setting?.gsmSenderId),
   [WHATSAPP]: (setting) => resolveValue(setting?.senderMobNum),
   [RCS]: (setting) => resolveValue(setting?.senderMobNum) || resolveValue(setting?.rcsSender),
@@ -75,8 +74,6 @@ const CommunicationFlowCard = ({
   onChange,
   cap,
   intl,
-  disabled,
-  disabledTooltip,
 }) => {
   const { formatMessage } = intl || {};
   const [showSlideBox, setShowSlideBox] = useState(false);
@@ -94,9 +91,8 @@ const CommunicationFlowCard = ({
   }, [onCancel]);
 
   const handleOpen = useCallback(() => {
-    if (disabled) return;
     setShowSlideBox(true);
-  }, [disabled]);
+  }, []);
 
   const firstItem = savedData?.contentItems?.[0];
   const channelConfig = firstItem
@@ -186,17 +182,9 @@ const CommunicationFlowCard = ({
               <CapImage src={addCreativesIllustration} />
             </CapColumn>
             <CapColumn span={14} className="empty-card-action-col">
-              {disabled && disabledTooltip ? (
-                <CapTooltip title={disabledTooltip}>
-                  <CapButton type="secondary" disabled>
-                    {formatMessage(messages.addCreatives)}
-                  </CapButton>
-                </CapTooltip>
-              ) : (
-                <CapButton type="secondary" onClick={handleOpen} disabled={disabled}>
-                  {formatMessage(messages.addCreatives)}
-                </CapButton>
-              )}
+              <CapButton type="secondary" onClick={handleOpen}>
+                {formatMessage(messages.addCreatives)}
+              </CapButton>
             </CapColumn>
           </CapRow>
         </CapCard>
@@ -239,8 +227,6 @@ CommunicationFlowCard.propTypes = {
   onChange: PropTypes.func,
   cap: PropTypes.object,
   intl: PropTypes.object.isRequired,
-  disabled: PropTypes.bool, // Disables the "Add creatives" trigger (e.g. until a consumer-required field is filled)
-  disabledTooltip: PropTypes.node, // Shown on hover when disabled is true
 };
 
 CommunicationFlowCard.defaultProps = {
@@ -249,8 +235,6 @@ CommunicationFlowCard.defaultProps = {
   onCancel: null,
   onChange: null,
   cap: null,
-  disabled: false,
-  disabledTooltip: null,
 };
 
 export default injectIntl(CommunicationFlowCard);

package/v2Containers/CommunicationFlow/Tests/CommunicationFlow.test.js

@@ -1,7 +1,8 @@
 import React from 'react';
 
 jest.mock('../../../services/api', () => ({
-  createCommDefinition: jest.fn(),
+  createCentralCommsMetaId: jest.fn(),
+  getCentralCommsMetaIds: jest.fn(),
 }));
 
 jest.mock('../../CreativesContainer', () => function MockCreativesContainer({
@@ -37,7 +38,7 @@ import { IntlProvider } from 'react-intl';
 import history from '../../../utils/history';
 import { initialReducer } from '../../../initialReducer';
 import CommunicationFlow from '../CommunicationFlow';
-import { createCommDefinition } from '../../../services/api';
+import { createCentralCommsMetaId, getCentralCommsMetaIds } from '../../../services/api';
 import { getEnabledSteps } from '../utils/getEnabledSteps';
 import {
   CHANNELS,
@@ -358,241 +359,82 @@ describe('isSaveDisabled', () => {
 });
 
 describe('handleSave — CCS flow', () => {
-  const ccsConfig = { ...baseConfig, context: { name: 'Order Placed Notification' }, features: {} };
-
   beforeEach(() => {
-    createCommDefinition.mockResolvedValue({
-      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 1 } } },
-    });
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'meta-123' } } });
+    getCentralCommsMetaIds.mockResolvedValue({ response: { data: {} } });
   });
 
   afterEach(() => {
     jest.clearAllMocks();
   });
 
-  it('calls createCommDefinition with a SINGLE-strategy payload when useCCS is not false', async () => {
+  it('calls createCentralCommsMetaId for each content item when useCCS is not false', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: {
-        contentItems: [{ channel: 'sms', templateData: { message: 'Hello' } }],
+        contentItems: [{ channel: 'sms', templateData: { smsBody: 'Hello' } }],
       },
       onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalledTimes(1));
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
       expect.objectContaining({
-        name: 'Order Placed Notification',
-        strategyType: 'SINGLE',
-        singleChannelStrategy: expect.objectContaining({
-          variant: expect.objectContaining({
-            channel: 'SMS',
-            smsMessageContent: { channel: 'SMS', message: 'Hello' },
-          }),
-        }),
+        centralCommsPayload: expect.objectContaining({ channel: 'SMS', module: 'CAMPAIGNS' }),
       }),
     );
     expect(onSave).toHaveBeenCalledTimes(1);
   });
 
-  it('transforms EMAIL content from the legacy editor shape (emailSubject) to CCS\'s messageSubject', async () => {
-    const onSave = jest.fn();
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: {
-        contentItems: [{
-          channel: 'EMAIL',
-          templateData: { emailSubject: 'Order Confirmed', emailBody: '<html>Hi</html>' },
-        }],
-      },
-      onSave,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).toHaveBeenCalledWith(
-      expect.objectContaining({
-        singleChannelStrategy: expect.objectContaining({
-          variant: expect.objectContaining({
-            channel: 'EMAIL',
-            emailMessageContent: {
-              channel: 'EMAIL',
-              messageSubject: 'Order Confirmed',
-              messageBody: '<html>Hi</html>',
-            },
-          }),
-        }),
-      }),
-    );
-  });
-
-  it('transforms WEBPUSH content from the legacy editor\'s messageContent.content wrapping to CCS\'s flat shape', async () => {
-    const onSave = jest.fn();
-    const cta = { type: 'SITE_URL', actionLink: 'https://example.com' };
-    const expandableDetails = { media: [{ url: 'https://example.com/banner.png', type: 'IMAGE' }], ctas: [] };
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: {
-        contentItems: [{
-          channel: 'WEBPUSH',
-          templateData: {
-            messageContent: {
-              content: {
-                channel: 'WEBPUSH',
-                accountId: 13792,
-                content: { title: 'Hi', message: 'Body', iconImageUrl: 'https://example.com/icon.png', cta, expandableDetails },
-                messageSubject: 'Subject',
-                offers: [],
-              },
-            },
-          },
-        }],
-      },
-      onSave,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).toHaveBeenCalledWith(
-      expect.objectContaining({
-        singleChannelStrategy: expect.objectContaining({
-          variant: expect.objectContaining({
-            channel: 'WEBPUSH',
-            webPushMessageContent: {
-              channel: 'WEBPUSH',
-              messageSubject: 'Subject',
-              accountId: 13792,
-              content: { title: 'Hi', message: 'Body', iconImageUrl: 'https://example.com/icon.png', cta, expandableDetails },
-            },
-          }),
-        }),
-      }),
-    );
-  });
-
-  it('normalizes the internal MOBILEPUSH channel to CCS\'s PUSH enum (keys stay mpush*), even when templateData/channelSetting carry their own stray channel field', async () => {
-    const onSave = jest.fn();
+  it('calls getCentralCommsMetaIds when metaIds are returned from createCentralCommsMetaId', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
-      initialData: {
-        // `channel: 'MOBILEPUSH'` inline on templateData reproduces the real
-        // production bug: contentItem.templateData carries the UI's own
-        // internal channel identifier, which must not win over the
-        // normalized 'PUSH' enum once spread into mpushMessageContent.
-        contentItems: [{ channel: 'MOBILEPUSH', templateData: { channel: 'MOBILEPUSH', messageSubject: 'Hi' } }],
-        // Likewise, deliverySetting.channelSetting.PUSH carrying its own
-        // stray `channel` key must not win over the normalized value once
-        // spread into mpushDeliverySettings.channelSettings.
-        deliverySetting: { channelSetting: { PUSH: { channel: 'MOBILEPUSH', domainId: 2002 } } },
-      },
-      onSave,
+      initialData: { contentItems: [{ channel: 'EMAIL', templateData: {} }] },
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).toHaveBeenCalledWith(
-      expect.objectContaining({
-        singleChannelStrategy: expect.objectContaining({
-          variant: expect.objectContaining({
-            channel: 'PUSH',
-            mpushMessageContent: { channel: 'PUSH', messageSubject: 'Hi' },
-            mpushDeliverySettings: {
-              channelSettings: { channel: 'PUSH', domainId: 2002 },
-            },
-          }),
-        }),
-      }),
-    );
+    await waitFor(() => expect(getCentralCommsMetaIds).toHaveBeenCalledWith('meta-123'));
   });
 
-  it('merges ccsCommDefinition into the data passed to onSave when create succeeds', async () => {
-    const onSave = jest.fn();
+  it('skips getCentralCommsMetaIds when response contains no id', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: {} } });
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(onSave).toHaveBeenCalledWith(
-      expect.objectContaining({
-        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 1, status: 'DRAFT' },
-      }),
-    );
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(getCentralCommsMetaIds).not.toHaveBeenCalled();
   });
 
-  it('preserves a real version of 0 from CCS (not coerced to 1 by a falsy-zero fallback)', async () => {
-    const onSave = jest.fn();
-    createCommDefinition.mockResolvedValueOnce({
-      response: { data: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', status: 'DRAFT', version: { version: 0 } } },
-    });
+  it('uses ouId and module from config.context when provided', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
+      config: { ...baseConfig, context: { ouId: 42, module: 'LOYALTY' }, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(onSave).toHaveBeenCalledWith(
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
       expect.objectContaining({
-        ccsCommDefinition: { id: 'cd_123', referenceId: 'ORDER_PLACED_123', version: 0, status: 'DRAFT' },
+        centralCommsPayload: expect.objectContaining({ ouId: 42, module: 'LOYALTY' }),
       }),
     );
   });
 
-  it('generates a referenceId from name when config.context.referenceId is absent', async () => {
-    // moduleMocks.js spies on Date.now globally, but this config's resetMocks:true
-    // clears that return value before every test — set it explicitly here.
-    jest.spyOn(Date, 'now').mockReturnValue(1612267539410);
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
-    const payload = createCommDefinition.mock.calls[0][0];
-    expect(payload.referenceId).toBe('ORDER_PLACED_NOTIFICATION_1612267539410');
-  });
-
-  it('uses config.context.referenceId and description when provided', async () => {
-    renderWithFlow({
-      features: {},
-      config: { ...ccsConfig, context: { ...ccsConfig.context, referenceId: 'ORDER_PLACED', description: 'desc' } },
-      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
-    expect(createCommDefinition).toHaveBeenCalledWith(
-      expect.objectContaining({ referenceId: 'ORDER_PLACED', description: 'desc' }),
-    );
-  });
-
   it('skips CCS entirely when useCCS is false', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...ccsConfig, useCCS: false },
+      config: { ...baseConfig, useCCS: false, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -600,15 +442,14 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
-    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
   });
 
-  it('skips createCommDefinition when config.context.name is absent (mandatory)', async () => {
+  it('still calls onSave when createCentralCommsMetaId rejects', async () => {
+    createCentralCommsMetaId.mockRejectedValue(new Error('Network error'));
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
       onSave,
     });
@@ -616,70 +457,12 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
-  });
-
-  it('skips createCommDefinition for multi-channel strategies (CHANNEL_PRIORITY/AB_TEST)', async () => {
-    const onSave = jest.fn();
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: {
-        communicationStrategy: CHANNEL_PRIORITY,
-        channels: ['SMS', 'EMAIL'],
-        contentItems: [{ channel: 'SMS', templateData: {} }, { channel: 'EMAIL', templateData: {} }],
-      },
-      onSave,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
   });
 
-  it('still calls onSave (without ccsCommDefinition) when createCommDefinition rejects', async () => {
-    createCommDefinition.mockRejectedValue(new Error('Network error'));
+  it('skips createCentralCommsMetaId when contentItems is empty', async () => {
     const onSave = jest.fn();
     renderWithFlow({
       features: {},
-      config: ccsConfig,
-      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(onSave).toHaveBeenCalledWith(expect.not.objectContaining({ ccsCommDefinition: expect.anything() }));
-  });
-
-  it('blocks save and shows an error when createCommDefinition resolves with a duplicate REFERENCE_ID_EXISTS conflict', async () => {
-    createCommDefinition.mockResolvedValue({
-      success: false,
-      status: { isError: true, code: 409, message: 'REFERENCE_ID_EXISTS' },
-      message: 'REFERENCE_ID_EXISTS',
-    });
-    const onSave = jest.fn();
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalledTimes(1));
-    expect(await screen.findByText(/already in use in your organization/i)).toBeInTheDocument();
-    expect(onSave).not.toHaveBeenCalled();
-  });
-
-  it('skips createCommDefinition when contentItems is empty', async () => {
-    const onSave = jest.fn();
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
       initialData: { contentItems: [] },
       onSave,
     });
@@ -687,13 +470,12 @@ describe('handleSave — CCS flow', () => {
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
     await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    expect(createCentralCommsMetaId).not.toHaveBeenCalled();
   });
 
-  it('places additionalSettings derived from dynamicControls under settings.additionalSettings (not delivery settings)', async () => {
+  it('includes additionalSettings derived from dynamicControls in the payload', async () => {
     renderWithFlow({
       features: {},
-      config: ccsConfig,
       initialData: {
         contentItems: [{ channel: 'SMS', templateData: {} }],
         dynamicControls: {
@@ -707,36 +489,14 @@ describe('handleSave — CCS flow', () => {
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
-    const payload = createCommDefinition.mock.calls[0][0];
-    expect(payload.settings.additionalSettings).toEqual({
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    const payload = createCentralCommsMetaId.mock.calls[0][0];
+    expect(payload.centralCommsPayload.smsDeliverySettings.additionalSettings).toEqual({
       useTinyUrl: true,
       encryptUrl: true,
       linkTrackingEnabled: true,
       userSubscriptionDisabled: true,
     });
-    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.additionalSettings).toBeUndefined();
-  });
-
-  it('includes channelSettings from deliverySetting.channelSetting in the payload', async () => {
-    renderWithFlow({
-      features: {},
-      config: ccsConfig,
-      initialData: {
-        contentItems: [{ channel: 'SMS', templateData: {} }],
-        deliverySetting: { channelSetting: { SMS: { domainId: 1001, gsmSenderId: 'BRAND1' } } },
-      },
-    });
-
-    await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
-
-    await waitFor(() => expect(createCommDefinition).toHaveBeenCalled());
-    const payload = createCommDefinition.mock.calls[0][0];
-    expect(payload.singleChannelStrategy.variant.smsDeliverySettings.channelSettings).toEqual({
-      channel: 'SMS',
-      domainId: 1001,
-      gsmSenderId: 'BRAND1',
-    });
   });
 });
 
@@ -792,34 +552,39 @@ describe('optional chaining safety', () => {
     jest.clearAllMocks();
   });
 
-  it('does not crash and skips CCS when config.context is entirely absent', async () => {
-    const onSave = jest.fn();
+  it('defaults ouId to -1 when config.context is absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ ouId: -1 }),
+      }),
+    );
   });
 
-  it('does not crash when config.context is present but empty', async () => {
-    const onSave = jest.fn();
+  it('defaults module to consumer.toUpperCase() when config.context.module absent', async () => {
+    createCentralCommsMetaId.mockResolvedValue({ response: { data: { id: 'x' } } });
     renderWithFlow({
       features: {},
-      config: { ...baseConfig, context: {}, features: {} },
+      config: { ...baseConfig, consumer: 'loyalty', features: {} },
       initialData: { contentItems: [{ channel: 'SMS', templateData: {} }] },
-      onSave,
     });
 
     await userEvent.click(screen.getByRole('button', { name: /^save$/i }));
 
-    await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
-    expect(createCommDefinition).not.toHaveBeenCalled();
+    await waitFor(() => expect(createCentralCommsMetaId).toHaveBeenCalled());
+    expect(createCentralCommsMetaId).toHaveBeenCalledWith(
+      expect.objectContaining({
+        centralCommsPayload: expect.objectContaining({ module: 'LOYALTY' }),
+      }),
+    );
   });
 
   it('initializes channel from config.channel when initialData.channel is absent', () => {

package/v2Containers/CommunicationFlow/Tests/CommunicationFlowCard.test.js

@@ -108,22 +108,6 @@ describe('CommunicationFlowCard', () => {
       fireEvent.click(screen.getByText('Add creatives'));
       expect(screen.getByTestId('comm-flow-mock')).toHaveAttribute('data-mode', 'create');
     });
-
-    it('disables the Add creatives button when disabled prop is true', () => {
-      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
-      expect(screen.getByText('Add creatives').closest('button')).toBeDisabled();
-    });
-
-    it('does not open SlideBox when Add creatives is clicked while disabled', () => {
-      renderCard({ disabled: true, disabledTooltip: 'Enter an Alert name to add content' });
-      fireEvent.click(screen.getByText('Add creatives'));
-      expect(screen.queryByTestId('slide-box')).not.toBeInTheDocument();
-    });
-
-    it('Add creatives button is enabled by default (disabled prop absent)', () => {
-      renderCard();
-      expect(screen.getByText('Add creatives').closest('button')).not.toBeDisabled();
-    });
   });
 
   describe('configured state (initialData provided)', () => {
@@ -247,11 +231,11 @@ describe('CommunicationFlowCard', () => {
       expect(screen.getByText(/Sender ID/)).toBeInTheDocument();
     });
 
-    it('shows senderId for EMAIL with Sender ID label', () => {
+    it('shows senderEmail for EMAIL with Sender ID label', () => {
       renderCard({
         initialData: makeSavedData({
           contentItems: [{ channel: 'EMAIL', templateData: {} }],
-          deliverySetting: { channelSetting: { EMAIL: { senderId: 'test@example.com' } } },
+          deliverySetting: { channelSetting: { EMAIL: { senderEmail: 'test@example.com' } } },
         }),
       });
       expect(screen.getByText(/test@example.com/)).toBeInTheDocument();

package/v2Containers/CommunicationFlow/constants.js

@@ -38,86 +38,6 @@ export const CHANNEL_PRIORITY = 'CHANNEL_PRIORITY';
 export const AB_TEST = 'AB_TEST';
 export const SINGLE_TEMPLATE = 'SINGLE_TEMPLATE';
 
-// CCS CommDefinition strategyType — distinct from SINGLE_TEMPLATE above, which
-// is this UI's own communicationStrategy value. Only SINGLE is supported this
-// phase; CCS create is skipped entirely for CHANNEL_PRIORITY/AB_TEST.
-export const CCS_STRATEGY_TYPE_SINGLE = 'SINGLE';
-
-// Mirrors CCS's SingleChannelStrategy field names exactly (Cap Notify API
-// Design doc sample payloads, verified against real create responses). Kept
-// separate from CHANNEL_CONTENT_KEY_MAP/CHANNEL_DELIVERY_KEY_MAP below, which
-// are the legacy messageMeta payload's keys.
-export const CCS_CHANNEL_CONTENT_KEY_MAP = {
-  SMS: 'smsMessageContent',
-  EMAIL: 'emailMessageContent',
-  WHATSAPP: 'whatsappMessageContent',
-  // CCS's channel enum value for mobile push is 'PUSH' (verified against real
-  // create responses), even though the content/delivery keys stay 'mpush*'.
-  PUSH: 'mpushMessageContent',
-  INAPP: 'inAppMessageContent',
-  ANDROID: 'androidMessageContent',
-  IOS: 'iosMessageContent',
-  ZALO: 'zaloMessageContent',
-  VIBER: 'viberMessageContent',
-  LINE: 'lineMessageContent',
-  WEBPUSH: 'webPushMessageContent',
-  RCS: 'rcsMessageContent',
-};
-
-// contentItem.templateData is built by the legacy CreativesContainer content
-// editor (messageMeta-oriented field names) — for channels whose legacy field
-// names don't match CCS's own content schema, transform before sending rather
-// than dumping templateData as-is. EMAIL: legacy stores the subject as
-// `emailSubject` and the HTML body as `emailBody` (see
-// extractContentForPreview.js and CreativesContainer/index.js, where the Bee
-// editor's output is written back into templateData.emailBody — also
-// mirrored by the existing legacy emailMessageContent builder in
-// utils/transformerUtils.js). CCS expects `messageSubject`/`messageBody`.
-export const CCS_CONTENT_TRANSFORMS = {
-  EMAIL: (templateData = {}) => ({
-    messageSubject: templateData.emailSubject,
-    messageBody: templateData.emailBody || templateData.emailHtml,
-  }),
-  // WEBPUSH: the legacy editor nests the real data under
-  // messageContent.content (see CommunicationFlowCard.js's own comment on
-  // this same wrapping, for the edit-mode case) — extracting it flat here
-  // matches CCS's shape ({ messageSubject, accountId, content }); `offers`
-  // (a legacy-only field) is deliberately dropped, not part of CCS's schema.
-  WEBPUSH: (templateData = {}) => {
-    const inner = templateData.messageContent?.content || templateData;
-    return {
-      messageSubject: inner.messageSubject,
-      accountId: inner.accountId,
-      content: inner.content,
-    };
-  },
-};
-
-export const CCS_CHANNEL_DELIVERY_KEY_MAP = {
-  SMS: 'smsDeliverySettings',
-  EMAIL: 'emailDeliverySettings',
-  WHATSAPP: 'whatsappDeliverySettings',
-  PUSH: 'mpushDeliverySettings',
-  INAPP: 'inAppDeliverySettings',
-  ANDROID: 'androidDeliverySettings',
-  IOS: 'iosDeliverySettings',
-  ZALO: 'zaloDeliverySettings',
-  VIBER: 'viberDeliverySettings',
-  LINE: 'lineDeliverySettings',
-  WEBPUSH: 'webPushDeliverySettings',
-  RCS: 'rcsDeliverySettings',
-};
-
-// The UI's own internal channel identifier for mobile push is 'MOBILEPUSH'
-// (see CreativesContainer/constants.js MOBILE_PUSH), but CCS's channel enum
-// value is 'PUSH' (verified against real create responses — the content/
-// delivery KEYS still say 'mpush*', only the enum VALUE is 'PUSH') —
-// normalize before building the CCS payload. Every other channel identifier
-// matches CCS as-is.
-export const CCS_CHANNEL_NAME_MAP = {
-  MOBILEPUSH: 'PUSH',
-};
-
 // Channel config - single source of truth for CreativesContainer and TemplatesV2
 // paneKey: TemplatesV2 defaultPanes object key (for channelsToHide)
 // channelProp: CreativesContainer channel prop (must match pane.key for tab to be active)
@@ -312,4 +232,4 @@ export const INCENTIVE_TYPES = [
   {
     value: 'badges', label: <FormattedMessage {...messages.badges} />, isActive: false, disabled: false,
   },
-];
+];

package/v2Containers/CommunicationFlow/index.js

@@ -9,6 +9,7 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import CommunicationFlow from './CommunicationFlow';
+import { hasSupportEngagementModule } from '../../utils/common';
 
 const CommunicationFlowContainer = ({
   config,
@@ -17,16 +18,22 @@ const CommunicationFlowContainer = ({
   onCancel,
   onChange,
   ...otherProps
-}) => (
-  <CommunicationFlow
-    config={config}
-    initialData={initialData}
-    onSave={onSave}
-    onCancel={onCancel}
-    onChange={onChange}
-    {...otherProps}
-  />
-);
+}) => {
+  if (!hasSupportEngagementModule()) {
+    return null;
+  }
+
+  return (
+    <CommunicationFlow
+      config={config}
+      initialData={initialData}
+      onSave={onSave}
+      onCancel={onCancel}
+      onChange={onChange}
+      {...otherProps}
+    />
+  );
+};
 
 CommunicationFlowContainer.propTypes = {
   config: PropTypes.shape({
@@ -80,13 +87,11 @@ CommunicationFlowContainer.propTypes = {
         controls: PropTypes.array,
       }),
     }),
-    context: PropTypes.object, // ouId, campaignId, programId; name (required for CCS create),
-    // referenceId (optional, auto-generated from name if absent), description (optional).
-    useCCS: PropTypes.bool, // If false, skips the CCS createCommDefinition call on save. Defaults to true.
+    context: PropTypes.object, // ouId, campaignId, programId, etc.
+    useCCS: PropTypes.bool, // If false, skips CCS bulk-claim-approve on save. Defaults to true.
   }).isRequired,
   initialData: PropTypes.object, // for edit/preview mode
-  onSave: PropTypes.func.isRequired, // (data) => void - called when user saves; data.ccsCommDefinition
-  // ({id, referenceId, version, status}) is present when the CCS create succeeded
+  onSave: PropTypes.func.isRequired, // (data) => void - called when user saves
   onCancel: PropTypes.func.isRequired, // () => void - called when user cancels
   onChange: PropTypes.func, // (data) => void - optional, called on data changes
 };

package/v2Containers/CommunicationFlow/messages.js

@@ -363,8 +363,4 @@ export default {
     id: `${prefix}.senderNotConfiguredError`,
     defaultMessage: 'Selected domain gateway id is not correct. Please change the domain id or contact the gateway team to register them with Capillary.',
   },
-  duplicateReferenceIdError: {
-    id: `${prefix}.duplicateReferenceIdError`,
-    defaultMessage: 'This reference ID is already in use in your organization. Please use a different reference ID.',
-  },
 };

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/SenderDetails.js

@@ -29,7 +29,6 @@ import {
   getEmailDefaultsForDomainId,
   getSmsDefaultsForDomainId,
   getRcsAccountName,
-  getEmailDomainGatewayMapIdByDomainId,
 } from './deliverySettingsConfig';
 import messages from '../../messages';
 import './SenderDetails.scss';
@@ -152,11 +151,6 @@ const SenderDetails = ({
           saveValues.whatsappDomainId = matchedDomain?.domainProperties?.id ?? matchedDomain?.domainId ?? matchedDomain?.id;
         }
       }
-      // Include EMAIL domainGatewayMapId derived from the selected domain for persistence -
-      // CCS needs it alongside domainId, but it's not a user-facing field.
-      if (entity && fieldValues.emailDomain != null && fieldValues.emailDomain !== '') {
-        saveValues.emailDomainGatewayMapId = getEmailDomainGatewayMapIdByDomainId(entity, fieldValues.emailDomain);
-      }
       onSave(saveValues);
     }
     onClose();

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/Tests/SenderDetails.test.js

@@ -83,7 +83,6 @@ const ENTITIES = {
   emailTwoDomains: {
     EMAIL: [
       {
-        id: 'gwmap-a',
         domainProperties: {
           id: 'em-a',
           domainName: 'Mail Alpha',
@@ -102,7 +101,6 @@ const ENTITIES = {
         },
       },
       {
-        id: 'gwmap-b',
         domainProperties: {
           id: 'em-b',
           domainName: 'Mail Beta',
@@ -324,29 +322,6 @@ describe('SenderDetails', () => {
     });
   });
 
-  it('persists emailDomainGatewayMapId derived from the selected email domain on save', async () => {
-    const { onSave } = renderSenderDetails({
-      channels: ['EMAIL'],
-      preloadedDomainProperties: ENTITIES.emailTwoDomains,
-    });
-    const root = document.querySelector('.sender-details');
-    await waitFor(() => expect(within(root).getByText('Mail Alpha')).toBeInTheDocument());
-
-    await openSelectAndChoose(root, 0, 'Mail Beta');
-    await waitFor(() => expect(within(root).getByText('beta@other.com')).toBeInTheDocument());
-
-    const saveBtn = within(root).getByRole('button', { name: /save changes/i });
-    await waitFor(() => expect(saveBtn).not.toBeDisabled());
-    fireEvent.click(saveBtn);
-
-    expect(onSave).toHaveBeenCalledWith(
-      expect.objectContaining({
-        emailDomain: 'em-b',
-        emailDomainGatewayMapId: 'gwmap-b',
-      }),
-    );
-  });
-
   it('resets email domain row back to the first gateway', async () => {
     renderSenderDetails({
       channels: ['EMAIL'],

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/Tests/deliverySettingsConfig.test.js

@@ -438,7 +438,6 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         smsDomain: 'd1',
         smsSenderId: 'g1',
         emailDomain: 'ed',
-        emailDomainGatewayMapId: 'gwmap-1',
         emailSenderId: 'mail@x.com',
         emailSenderName: 'N',
         emailReplyToId: 'r@x.com',
@@ -456,10 +455,9 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         SMS: { domainId: 'd1', gsmSenderId: 'g1' },
         EMAIL: {
           domainId: 'ed',
-          domainGatewayMapId: 'gwmap-1',
-          senderId: 'mail@x.com',
+          senderEmail: 'mail@x.com',
           senderLabel: 'N',
-          replyToId: 'r@x.com',
+          senderReplyTo: 'r@x.com',
         },
         WHATSAPP: { domainId: 'wd', senderMobNum: '+w' },
         RCS: { senderMobNum: '+r', rcsSender: '+r' },
@@ -474,10 +472,9 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         SMS: { domainId: 'd', gsmSenderId: 'g' },
         EMAIL: {
           domainId: 'ed',
-          domainGatewayMapId: 'gwmap-2',
-          senderId: 'e@e.com',
+          senderEmail: 'e@e.com',
           senderLabel: 'L',
-          replyToId: 'r@e.com',
+          senderReplyTo: 'r@e.com',
         },
         WHATSAPP: { senderMobNum: '+w', domainId: 'wid' },
         RCS: { rcsSender: '+r' },
@@ -489,10 +486,6 @@ describe('deliverySettingsConfig — user-facing flows', () => {
         smsDomain: 'd',
         smsSenderId: 'g',
         emailDomain: 'ed',
-        emailDomainGatewayMapId: 'gwmap-2',
-        emailSenderId: 'e@e.com',
-        emailSenderName: 'L',
-        emailReplyToId: 'r@e.com',
         whatsappDomainId: 'wid',
         viberSenderId: 'vx',
       });

package/v2Containers/CommunicationFlow/steps/DeliverySettingsStep/deliverySettingsConfig.js

@@ -181,14 +181,6 @@ const getEmailDomainValue = (entity) => {
   return emailData.domainProperties?.id ?? emailData.domainId ?? emailData.id ?? '';
 };
 
-// CCS's domainGatewayMapId is the domainProperties API's own outer `id`
-// (distinct from `domainProperties.id`, which is the numeric domainId) - the
-// domain-gateway-mapping id for the selected domain entry.
-const getEmailDomainGatewayMapIdByDomainId = (entity, domainId) => {
-  const domainEntry = getEmailDomainById(entity, domainId);
-  return domainEntry?.id ?? '';
-};
-
 /** Domain name for summary display (parseEntityForDisplay) */
 const getEmailDomainNameForDisplay = (entity) => {
   const emailData = getEmailData(entity);
@@ -270,8 +262,6 @@ const getEmailDefaultsForDomain = (domainData) => {
  * context.fieldValues has current form state (e.g. selected emailDomain)
  * Aligned with adiona-ui/cap-campaigns-v2: default = contactInfo item with default:true, or first
  */
-export { getEmailDomainGatewayMapIdByDomainId };
-
 export const getDefaultValueForField = (fieldKey, entity, context = {}) => {
   if (!entity) return '';
   const fieldValues = context?.fieldValues || {};
@@ -584,11 +574,7 @@ export const parseEntityForDisplay = (entity, context = {}) => {
     senderDetails: entity,
     smsSenderId: getSmsSenderIdValue(entity),
     smsDomain: getSmsDomainValue(entity),
-    // emailDomain here is the domain NAME (for display only) - buildChannelSettingFromFieldValues
-    // needs the numeric domainId/domainGatewayMapId, sourced separately below.
     emailDomain: getEmailDomainNameForDisplay(entity),
-    emailDomainId: getEmailDomainValue(entity),
-    emailDomainGatewayMapId: getEmailDomainGatewayMapIdByDomainId(entity, getEmailDomainValue(entity)),
     emailSenderId: getEmailSenderIdValue(entity),
     viberSenderId: getSenderIdFromContactInfo(entity, 'VIBER'),
     zaloSenderId: getSenderIdFromContactInfo(entity, 'ZALO'),
@@ -614,14 +600,10 @@ export const buildChannelSettingFromFieldValues = (fieldValues = {}) => {
   }
   if (fieldValues.emailDomain != null || fieldValues.emailSenderId != null || fieldValues.emailSenderName != null || fieldValues.emailReplyToId != null) {
     channelSetting.EMAIL = {
-      // emailDomainId (numeric, from the auto-save-defaults path via parseEntityForDisplay)
-      // takes priority over emailDomain, which is numeric when sourced from SenderDetails'
-      // own field state but a display NAME string when sourced from parseEntityForDisplay.
-      domainId: fieldValues.emailDomainId ?? fieldValues.emailDomain,
-      domainGatewayMapId: fieldValues.emailDomainGatewayMapId,
-      senderId: fieldValues.emailSenderId,
+      domainId: fieldValues.emailDomain,
+      senderEmail: fieldValues.emailSenderId,
       senderLabel: fieldValues.emailSenderName,
-      replyToId: fieldValues.emailReplyToId,
+      senderReplyTo: fieldValues.emailReplyToId,
     };
   }
   if (fieldValues.whatsappSenderNumber != null || fieldValues.whatsappAccount != null) {
@@ -691,10 +673,9 @@ export const parseChannelSettingForDisplay = (channelSetting = {}) => {
   }
   if (channelSetting.EMAIL) {
     out.emailDomain = channelSetting.EMAIL.domainId;
-    out.emailDomainGatewayMapId = channelSetting.EMAIL.domainGatewayMapId;
-    out.emailSenderId = channelSetting.EMAIL.senderId;
+    out.emailSenderId = channelSetting.EMAIL.senderEmail;
     out.emailSenderName = channelSetting.EMAIL.senderLabel;
-    out.emailReplyToId = channelSetting.EMAIL.replyToId;
+    out.emailReplyToId = channelSetting.EMAIL.senderReplyTo;
   }
   if (channelSetting.WHATSAPP) {
     out.whatsappSenderNumber = channelSetting.WHATSAPP.senderMobNum;

package/v2Containers/MobilePush/Edit/index.js

@@ -1139,8 +1139,7 @@ export class Edit extends React.Component { // eslint-disable-line react/prefer-
       this.props.globalActions.addMessageToQueue(message);
     } else {
       const name = data.file.name.split('.');
-      const blob = data.file.slice(0, -1, 'image');
-      const newFile = new File([blob], `${name[0]}${Date.now()}.${name[1]}`, {type: 'image'});
+      const newFile = new File([data.file], `${name[0]}${Date.now()}.${name[1]}`, {type: 'image'});
       this.props.actions.uploadAsset(newFile, data.type, data.fileParams);
     }
   };