@capillarytech/creatives-library 8.0.353-alpha.5 → 8.0.353-alpha.6

package/v2Containers/Sms/Create/index.js

@@ -33,6 +33,10 @@ import injectReducer from '../../../utils/injectReducer';
 import v2SmsCreateReducer from './reducer';
 import * as globalActions from '../../Cap/actions';
 import TestAndPreviewSlidebox from '../../../v2Components/TestAndPreviewSlidebox';
+import {
+  getSmsEmbeddedFooterValidity,
+  getSmsMessageFromFormData,
+} from '../smsFormDataHelpers';
 
 export class Create extends React.Component { // eslint-disable-line react/prefer-stateless-function
   constructor(props) {
@@ -53,6 +57,11 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
       isTestAndPreviewMode: false,
       pendingGetFormData: false,
     };
+    // Tracks the last validity value reported to SmsFallback so componentDidUpdate
+    // does not dispatch on every render and create an infinite update loop.
+    // Intentionally undefined (not true) so the first render always reports the
+    // real validity rather than assuming the form starts invalid.
+    this._lastReportedSmsFooterInvalid = undefined;
     this.saveFormData = this.saveFormData.bind(this);
     this.onFormDataChange = this.onFormDataChange.bind(this);
     this.onTemplateNameChange = this.onTemplateNameChange.bind(this);
@@ -159,7 +168,9 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
           layout: 'SMS',
           type: 'TAG',
           context: this.props.location.query.type === 'embedded' ? this.props.location.query.module : 'default',
-          embedded: this.props.location.query.type === 'embedded' ? this.props.location.query.type : 'full',
+          embedded: this.props.forceFullTagContext
+            ? 'full'
+            : (this.props.location.query.type === 'embedded' ? this.props.location.query.type : 'full'),
         };
         if (this.props.getDefaultTags) {
           query.context = this.props.getDefaultTags;
@@ -172,6 +183,28 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
     }
   }
 
+  componentDidUpdate() {
+    if (!this.props.embeddedSmsFallback || typeof this.props.onEmbeddedSmsFooterValidity !== 'function') {
+      return;
+    }
+    const validity = getSmsEmbeddedFooterValidity(this.state.formData, this.state.tabCount);
+    const isTemplateNameEmpty = !!validity.isTemplateNameEmpty;
+    const isMessageEmpty = !!validity.isMessageEmpty;
+    // Only dispatch when the validity tuple changes. Dispatching unconditionally caused
+    // an infinite loop: componentDidUpdate → dispatch → SmsFallback re-render →
+    // SmsCreate re-render → componentDidUpdate → ... even when state was unchanged.
+    // Tracking both fields individually (not just the combined isInvalid flag) ensures
+    // the parent receives an updated validity object when individual fields flip even
+    // while the combined invalid state stays the same (e.g. true→true with different fields).
+    if (
+      this._lastReportedSmsFooterTemplateNameEmpty === isTemplateNameEmpty &&
+      this._lastReportedSmsFooterMessageEmpty === isMessageEmpty
+    ) return;
+    this._lastReportedSmsFooterTemplateNameEmpty = isTemplateNameEmpty;
+    this._lastReportedSmsFooterMessageEmpty = isMessageEmpty;
+    this.props.onEmbeddedSmsFooterValidity(validity);
+  }
+
   componentWillUnmount() {
     if (this.pendingGetFormDataTimeout) {
       clearTimeout(this.pendingGetFormDataTimeout);
@@ -275,6 +308,10 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
     }
     const result = {};
     result.base = baseData;
+    /* Root field used by FormBuilder; embedded getFormSubscriptionData reads value.base */
+    if (formData['template-name'] !== undefined) {
+      result.base['template-name'] = formData['template-name'];
+    }
     if (this.state.isValid) {
       const msgObj = charCount.updateCharCount(baseData['sms-editor']);
       result.base.msg_count = msgObj.msgCount;
@@ -884,7 +921,9 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
       layout: 'SMS',
       type: 'TAG',
       context: (data && data.toLowerCase() === 'all') ? 'default' : (data && data.toLowerCase()),
-      embedded: this.props.location.query.type === 'embedded' ? this.props.location.query.type : 'full',
+      embedded: this.props.forceFullTagContext
+        ? 'full'
+        : (this.props.location.query.type === 'embedded' ? this.props.location.query.type : 'full'),
     };
     this.props.globalActions.fetchSchemaForEntity(query);
   }
@@ -892,11 +931,29 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
   removeStandAlone() {
     const schema = _.cloneDeep(this.state.schema);
     const childSections = _.get(schema, 'standalone.sections[0].childSections');
-    childSections.splice(2, 1);
-    const fields = _.get(childSections, '[1].childSections[0].childSections');//removing template name section
-    fields.splice(0, 1);
-    _.set(childSections, '[1].childSections[0].childSections', fields);
-    _.set(schema, 'standalone.sections[0].childSections', childSections);
+    if (childSections) {
+      /* In-form Save / Test row (index 2) only exists when the schema has > 2 sections. */
+      if (childSections.length > 2) {
+        childSections.splice(2, 1);
+      }
+      /*
+       * Creatives library drops the standalone template-name block because `SlideBoxHeader`
+       * shows the name. This is independent of the section count — guard it separately so
+       * it still runs even when childSections.length <= 2 (e.g. schema arrives pre-trimmed).
+       * RCS SMS fallback uses the same slidebox footer but keeps the name in the form.
+       */
+      if (!this.props.embeddedSmsFallback) {
+        const fields = _.get(childSections, '[1].childSections[0].childSections');
+        if (fields && fields.length > 0) {
+          fields.splice(0, 1);
+          _.set(childSections, '[1].childSections[0].childSections', fields);
+        }
+      }
+      _.set(schema, 'standalone.sections[0].childSections', childSections);
+    }
+    // Always increment loadingStatus — isSmsLoading() requires >= 2 in library mode
+    // (isFullMode=false). The early return previously skipped this, leaving the
+    // spinner stuck forever when the schema had <= 2 childSections.
     this.setState({ schema, loadingStatus: this.state.loadingStatus + 1 });
   }
 
@@ -941,37 +998,8 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
     this.setState({startValidation: false});
   }
 
-  getTemplateContent = () => {
-    // Get SMS content from formData
-    if (!this.state.formData || !Array.isArray(this.state.formData) || this.state.formData.length === 0) {
-      return '';
-    }
-    const currentTabData = this.state.formData[this.state.currentTab - 1];
-    if (!currentTabData) {
-      return '';
-    }
-    
-    // PRIORITY 1: Check direct path first (most common for SMS)
-    // This handles: formData[0]['sms-editor']
-    if (currentTabData['sms-editor']) {
-      return currentTabData['sms-editor'];
-    }
-    
-    // PRIORITY 2: Check activeTab structure (for versioned templates)
-    // This handles: formData[0][activeTab]['sms-editor']
-    const activeTab = currentTabData?.activeTab || 'base';
-    if (currentTabData[activeTab]?.['sms-editor']) {
-      return currentTabData[activeTab]['sms-editor'];
-    }
-    
-    // PRIORITY 3: Check base explicitly (fallback)
-    // This handles: formData[0]['base']['sms-editor']
-    if (currentTabData['base']?.['sms-editor']) {
-      return currentTabData['base']['sms-editor'];
-    }
-    
-    return '';
-  }
+  getTemplateContent = () =>
+    getSmsMessageFromFormData(this.state.formData, this.state.currentTab);
 
   handleTestAndPreview = () => {
     // If parent is managing state (props exist), call parent handler
@@ -1000,6 +1028,35 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
   }
 
   saveFormData() {
+    /*
+     * RCS SMS fallback slidebox (embeddedSmsFallback): parent passes isFullMode from RCS, but we must not
+     * call createTemplate — that spins CapSpin on createTemplateInProgress and is not the embedded contract.
+     * Same as library: hand off form payload via getFormSubscriptionData.
+     */
+    if (this.props.embeddedSmsFallback && this.props.getFormSubscriptionData) {
+      const { isTemplateNameEmpty, isMessageEmpty } = getSmsEmbeddedFooterValidity(
+        this.state.formData,
+        this.state.tabCount,
+      );
+      if (isTemplateNameEmpty || isMessageEmpty) {
+        this.setState({ startValidation: true, pendingGetFormData: false });
+        if (this.props.onValidationFail) {
+          this.props.onValidationFail();
+        }
+        return;
+      }
+      const payload = this.getFormData();
+      if (!payload.validity) {
+        if (this.props.onValidationFail) {
+          this.props.onValidationFail();
+        }
+        this.setState({ pendingGetFormData: false, startValidation: false });
+        return;
+      }
+      this.props.getFormSubscriptionData(payload);
+      this.setState({ pendingGetFormData: false, startValidation: false });
+      return;
+    }
     // In library mode: FormBuilder calls onSubmit only after liquid validation succeeds.
     // Submit to parent here so the slidebox can close with valid data.
     if (!this.props.isFullMode) {
@@ -1099,7 +1156,9 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
                 onTestContentClicked={this.props.onTestContentClicked}
                 onPreviewContentClicked={this.props.onPreviewContentClicked}
                 eventContextTags={this.props?.eventContextTags}
-                waitEventContextTags={this.props?.waitEventContextTags}
+                tagListGetPopupContainer={this.props.tagListGetPopupContainer}
+                tagListPopoverOverlayStyle={this.props.tagListPopoverOverlayStyle}
+                tagListPopoverOverlayClassName={this.props.tagListPopoverOverlayClassName}
               />
             </CapColumn>
           </CapRow>
@@ -1112,6 +1171,7 @@ export class Create extends React.Component { // eslint-disable-line react/prefe
           formData={this.state.formData}
           content={this.getTemplateContent()}
           currentChannel={SMS}
+          smsRegister={this.props.smsRegister}
         />
       </div>
     );
@@ -1136,11 +1196,17 @@ Create.propTypes = {
   isLoadingMetaEntities: PropTypes.bool,
   selectedOfferDetails: PropTypes.array,
   eventContextTags: PropTypes.array,
-  waitEventContextTags: PropTypes.object,
   showTestAndPreviewSlidebox: PropTypes.bool,
   handleTestAndPreview: PropTypes.func,
   handleCloseTestAndPreview: PropTypes.func,
   isTestAndPreviewMode: PropTypes.bool,
+  smsRegister: PropTypes.any,
+  forceFullTagContext: PropTypes.bool,
+  embeddedSmsFallback: PropTypes.bool,
+  onEmbeddedSmsFooterValidity: PropTypes.func,
+  tagListGetPopupContainer: PropTypes.func,
+  tagListPopoverOverlayStyle: PropTypes.object,
+  tagListPopoverOverlayClassName: PropTypes.string,
 };
 
 const mapStateToProps = createStructuredSelector({

package/v2Containers/Sms/smsFormDataHelpers.js

@@ -0,0 +1,67 @@
+/**
+ * Shared SMS FormBuilder formData helpers for Sms/Create (and any embedded host).
+ */
+
+/**
+ * @param {object} formData FormBuilder state (same shape as Sms/Create `this.state.formData`)
+ * @param {number} currentTab 1-based tab index
+ * @returns {string} Raw message body or ''
+ */
+export function getSmsMessageFromFormData(formData, currentTab) {
+  if (formData == null || typeof formData !== 'object') {
+    return '';
+  }
+  const tab = currentTab != null && currentTab > 0 ? currentTab : 1;
+  const currentTabData = formData[tab - 1];
+  if (currentTabData && typeof currentTabData === 'object') {
+    const versionedKey = tab > 1 ? `sms-editor${tab}` : 'sms-editor';
+    if (Object.prototype.hasOwnProperty.call(currentTabData, versionedKey)) {
+      const v = currentTabData[versionedKey];
+      // Key exists — commit to this version's value rather than falling through to base.
+      // Treat null/undefined as empty so a cleared version correctly reports as empty.
+      return (v != null && v !== '') ? String(v) : '';
+    }
+    if (currentTabData['sms-editor'] != null) {
+      return String(currentTabData['sms-editor']);
+    }
+    const activeTab = currentTabData.activeTab || 'base';
+    if (currentTabData[activeTab]?.['sms-editor'] != null) {
+      return String(currentTabData[activeTab]['sms-editor']);
+    }
+    if (currentTabData.base?.['sms-editor'] != null) {
+      return String(currentTabData.base['sms-editor']);
+    }
+  }
+  const rootBase = formData.base;
+  if (rootBase && typeof rootBase === 'object' && rootBase['sms-editor'] != null) {
+    return String(rootBase['sms-editor']);
+  }
+  return '';
+}
+
+/**
+ * @param {number} [tabCount] Total number of versions/tabs. When >1 all versions are checked.
+ * @returns {{ isTemplateNameEmpty: boolean, isMessageEmpty: boolean }}
+ */
+export function getSmsEmbeddedFooterValidity(formData, tabCount) {
+  const rawName = formData?.['template-name'];
+  const name = rawName != null && rawName !== '' ? String(rawName).trim() : '';
+
+  // Check ALL versions: if any version's message is empty, Done should be disabled.
+  // With a single version this is equivalent to the previous single-tab check.
+  const count = tabCount != null && tabCount > 1 ? tabCount : 1;
+  let isMessageEmpty = false;
+  for (let i = 1; i <= count; i++) {
+    const content = getSmsMessageFromFormData(formData, i);
+    const msg = content != null && content !== '' ? String(content).trim() : '';
+    if (!msg) {
+      isMessageEmpty = true;
+      break;
+    }
+  }
+
+  return {
+    isTemplateNameEmpty: !name,
+    isMessageEmpty,
+  };
+}

package/v2Containers/Sms/tests/smsFormDataHelpers.test.js

@@ -0,0 +1,253 @@
+import {
+  getSmsMessageFromFormData,
+  getSmsEmbeddedFooterValidity,
+} from '../smsFormDataHelpers';
+
+// ---------------------------------------------------------------------------
+// getSmsMessageFromFormData
+// ---------------------------------------------------------------------------
+
+describe('getSmsMessageFromFormData', () => {
+  describe('null / invalid formData guard', () => {
+    it('returns empty string when formData is null', () => {
+      expect(getSmsMessageFromFormData(null, 1)).toBe('');
+    });
+
+    it('returns empty string when formData is undefined', () => {
+      expect(getSmsMessageFromFormData(undefined, 1)).toBe('');
+    });
+
+    it('returns empty string when formData is a string (not an object)', () => {
+      expect(getSmsMessageFromFormData('bad', 1)).toBe('');
+    });
+
+    it('returns empty string when formData is a number', () => {
+      expect(getSmsMessageFromFormData(42, 1)).toBe('');
+    });
+  });
+
+  describe('currentTab normalisation', () => {
+    it('defaults to tab 1 when currentTab is null', () => {
+      const formData = { 0: { 'sms-editor': 'hello' } };
+      expect(getSmsMessageFromFormData(formData, null)).toBe('hello');
+    });
+
+    it('defaults to tab 1 when currentTab is undefined', () => {
+      const formData = { 0: { 'sms-editor': 'hello' } };
+      expect(getSmsMessageFromFormData(formData, undefined)).toBe('hello');
+    });
+
+    it('defaults to tab 1 when currentTab is 0', () => {
+      const formData = { 0: { 'sms-editor': 'hello' } };
+      expect(getSmsMessageFromFormData(formData, 0)).toBe('hello');
+    });
+
+    it('defaults to tab 1 when currentTab is negative', () => {
+      const formData = { 0: { 'sms-editor': 'hello' } };
+      expect(getSmsMessageFromFormData(formData, -5)).toBe('hello');
+    });
+  });
+
+  describe('versioned key lookup', () => {
+    it('uses "sms-editor" key for tab 1', () => {
+      const formData = { 0: { 'sms-editor': 'tab1 msg' } };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('tab1 msg');
+    });
+
+    it('uses "sms-editor2" versioned key for tab 2', () => {
+      const formData = { 1: { 'sms-editor2': 'tab2 msg', 'sms-editor': 'fallback' } };
+      expect(getSmsMessageFromFormData(formData, 2)).toBe('tab2 msg');
+    });
+
+    it('uses "sms-editor3" versioned key for tab 3', () => {
+      const formData = { 2: { 'sms-editor3': 'tab3 msg' } };
+      expect(getSmsMessageFromFormData(formData, 3)).toBe('tab3 msg');
+    });
+
+    it('returns empty string when versioned key exists but is null (cleared version)', () => {
+      const formData = { 1: { 'sms-editor2': null } };
+      expect(getSmsMessageFromFormData(formData, 2)).toBe('');
+    });
+
+    it('returns empty string when versioned key exists but is empty string', () => {
+      const formData = { 1: { 'sms-editor2': '' } };
+      expect(getSmsMessageFromFormData(formData, 2)).toBe('');
+    });
+
+    it('coerces a numeric value in versioned key to string', () => {
+      const formData = { 1: { 'sms-editor2': 12345 } };
+      expect(getSmsMessageFromFormData(formData, 2)).toBe('12345');
+    });
+  });
+
+  describe('"sms-editor" flat key fallback (versioned key absent)', () => {
+    it('falls back to "sms-editor" when versioned key is absent for tab 2', () => {
+      const formData = { 1: { 'sms-editor': 'flat fallback' } };
+      expect(getSmsMessageFromFormData(formData, 2)).toBe('flat fallback');
+    });
+  });
+
+  describe('activeTab nested fallback', () => {
+    it('falls back to activeTab["sms-editor"] when neither versioned key nor flat "sms-editor" is present', () => {
+      // The versioned key must be absent entirely for the activeTab fallback to be reached.
+      // (If 'sms-editor' exists but is null, the function commits to '' without falling through.)
+      const formData = {
+        0: {
+          activeTab: 'variant1',
+          variant1: { 'sms-editor': 'variant msg' },
+        },
+      };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('variant msg');
+    });
+
+    it('falls back to base["sms-editor"] when activeTab entry lacks "sms-editor" and flat key is absent', () => {
+      const formData = {
+        0: {
+          activeTab: 'variant1',
+          variant1: {},
+          base: { 'sms-editor': 'base msg' },
+        },
+      };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('base msg');
+    });
+
+    it('defaults activeTab to "base" when activeTab prop is not set and flat key is absent', () => {
+      const formData = {
+        0: {
+          base: { 'sms-editor': 'default base msg' },
+        },
+      };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('default base msg');
+    });
+  });
+
+  describe('root formData.base fallback', () => {
+    it('falls back to formData.base["sms-editor"] when tab slot is missing', () => {
+      const formData = {
+        base: { 'sms-editor': 'root base msg' },
+      };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('root base msg');
+    });
+
+    it('returns empty string when even root base has no "sms-editor"', () => {
+      const formData = { base: {} };
+      expect(getSmsMessageFromFormData(formData, 1)).toBe('');
+    });
+
+    it('returns empty string when formData has no relevant keys at all', () => {
+      expect(getSmsMessageFromFormData({}, 1)).toBe('');
+    });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getSmsEmbeddedFooterValidity
+// ---------------------------------------------------------------------------
+
+describe('getSmsEmbeddedFooterValidity', () => {
+  describe('isTemplateNameEmpty', () => {
+    it('is true when template-name is absent', () => {
+      const formData = { 0: { 'sms-editor': 'msg' } };
+      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isTemplateNameEmpty).toBe(true);
+    });
+
+    it('is true when template-name is empty string', () => {
+      const formData = { 'template-name': '', 0: { 'sms-editor': 'msg' } };
+      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isTemplateNameEmpty).toBe(true);
+    });
+
+    it('is true when template-name is whitespace only', () => {
+      const formData = { 'template-name': '   ', 0: { 'sms-editor': 'msg' } };
+      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isTemplateNameEmpty).toBe(true);
+    });
+
+    it('is false when template-name is a non-empty string', () => {
+      const formData = { 'template-name': 'My Template', 0: { 'sms-editor': 'msg' } };
+      const { isTemplateNameEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isTemplateNameEmpty).toBe(false);
+    });
+  });
+
+  describe('isMessageEmpty — single tab', () => {
+    it('is true when message is empty string', () => {
+      const formData = { 'template-name': 'T', 0: { 'sms-editor': '' } };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isMessageEmpty).toBe(true);
+    });
+
+    it('is true when message is whitespace only', () => {
+      const formData = { 'template-name': 'T', 0: { 'sms-editor': '   ' } };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isMessageEmpty).toBe(true);
+    });
+
+    it('is true when no sms-editor key at all', () => {
+      const formData = { 'template-name': 'T', 0: {} };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isMessageEmpty).toBe(true);
+    });
+
+    it('is false when message is non-empty', () => {
+      const formData = { 'template-name': 'T', 0: { 'sms-editor': 'Hello world' } };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(isMessageEmpty).toBe(false);
+    });
+  });
+
+  describe('isMessageEmpty — multiple tabs', () => {
+    it('is false when all tabs have non-empty messages', () => {
+      const formData = {
+        'template-name': 'T',
+        0: { 'sms-editor': 'Tab 1 message' },
+        1: { 'sms-editor2': 'Tab 2 message' },
+        2: { 'sms-editor3': 'Tab 3 message' },
+      };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 3);
+      expect(isMessageEmpty).toBe(false);
+    });
+
+    it('is true when the second tab has an empty message', () => {
+      const formData = {
+        'template-name': 'T',
+        0: { 'sms-editor': 'Tab 1 message' },
+        1: { 'sms-editor2': '' },
+      };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 2);
+      expect(isMessageEmpty).toBe(true);
+    });
+
+    it('is true when the third tab has no message', () => {
+      const formData = {
+        'template-name': 'T',
+        0: { 'sms-editor': 'msg1' },
+        1: { 'sms-editor2': 'msg2' },
+        2: {},
+      };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData, 3);
+      expect(isMessageEmpty).toBe(true);
+    });
+
+    it('treats tabCount=1 as single-tab check even when not explicitly provided', () => {
+      const formData = { 'template-name': 'T', 0: { 'sms-editor': 'msg' } };
+      const { isMessageEmpty } = getSmsEmbeddedFooterValidity(formData);
+      expect(isMessageEmpty).toBe(false);
+    });
+  });
+
+  describe('both fields together', () => {
+    it('returns both empty when template name absent and message empty', () => {
+      const formData = { 0: { 'sms-editor': '' } };
+      const result = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(result).toEqual({ isTemplateNameEmpty: true, isMessageEmpty: true });
+    });
+
+    it('returns both non-empty when template name and message are present', () => {
+      const formData = { 'template-name': 'My Template', 0: { 'sms-editor': 'Hello!' } };
+      const result = getSmsEmbeddedFooterValidity(formData, 1);
+      expect(result).toEqual({ isTemplateNameEmpty: false, isMessageEmpty: false });
+    });
+  });
+});

package/v2Containers/SmsTrai/Create/index.js

@@ -70,6 +70,7 @@ export const SmsTraiCreate = (props) => {
     onCreateComplete,
     isFullMode,
     onShowTemplates,
+    embeddedSmsFallback,
     traiSms: {
       duplicateDetails = {},
       duplicateDetailsError = '',
@@ -659,9 +660,11 @@ export const SmsTraiCreate = (props) => {
 
   const createCallback = ({ errorMessage }) => {
     if (!errorMessage) {
-      CapNotification.success({
-        message: formatMessage(messages.smsCreateNotification),
-      });
+      if (!embeddedSmsFallback) {
+        CapNotification.success({
+          message: formatMessage(messages.smsCreateNotification),
+        });
+      }
       actions.clearCreateResponse();
     } else {
       CapNotification.error({
@@ -741,7 +744,9 @@ export const SmsTraiCreate = (props) => {
       { templates: savedData },
       (resp, errorMessage) => {
         createCallback({ errorMessage });
-        if (isFullMode) {
+        if (embeddedSmsFallback) {
+          if (!errorMessage) onCreateComplete(savedData);
+        } else if (isFullMode) {
           onCreateComplete();
         } else {
           onShowTemplates();

package/v2Containers/SmsTrai/Edit/constants.js

@@ -5,6 +5,8 @@
  */
 
 export const CHARLIMIT = 40;
+/** Display / soft cap label for DLT SMS body length (matches product UI). */
+export const SMS_TRAI_CONTENT_MAX_LENGTH = 1024;
 export const SMS = 'SMS';
 export const SMS_TRAI_VAR = '{#var#}';
 export const TAG = 'TAG';