@capillarytech/creatives-library 8.0.287-alpha.3 → 8.0.288

package/v2Containers/WebPush/Create/utils/validation.js

@@ -1,6 +1,7 @@
 import { isValidHttpUrl } from './urlValidation';
 import { validateTags } from '../../../../utils/tagValidations';
 import globalMessages from '../../../Cap/messages';
+import { hasPersonalizationTags } from '../../../../utils/commonUtils';
 
 /**
  * Validates template name (checks if empty)
@@ -10,31 +11,19 @@ import globalMessages from '../../../Cap/messages';
 export const validateTemplateName = (value) => !value || value.trim() === '';
 
 /**
- * Validates notification title (required and optional tag validation)
+ * Validates notification title
  * @param {string} value - The title value
  * @param {Function} formatMessage - i18n format message function
  * @param {Object} messages - Message definitions
- * @param {Object} [validationConfig] - Optional config for tag validation
- * @param {boolean} [isFullMode] - Optional; when set with validationConfig, runs tag validation
  * @returns {string} Error message if invalid, empty string if valid
  */
-export const validateTitle = (value, formatMessage, messages, validationConfig, isFullMode) => {
+export const validateTitle = (value, formatMessage, messages, restrictPersonalization) => {
   if (!value || value.trim() === '') {
     return formatMessage(messages.titleRequired);
   }
-
-  if (validationConfig != null) {
-    const validationResponse = validateTags({
-      content: value,
-      ...validationConfig,
-      isFullMode,
-    }) || {};
-
-    if (validationResponse?.isBraceError) {
-      return formatMessage(globalMessages.unbalanacedCurlyBraces);
-    }
+  if (restrictPersonalization && hasPersonalizationTags(value)) {
+    return formatMessage(messages.personalizationTokensErrorMessage);
   }
-
   return '';
 };
 
@@ -49,11 +38,11 @@ export const validateUrl = (value, formatMessage, messages) => {
   if (!value || value.trim() === '') {
     return formatMessage(messages.urlRequired);
   }
-  
+
   if (!isValidHttpUrl(value)) {
     return formatMessage(messages.urlInvalid);
   }
-  
+
   return '';
 };
 
@@ -65,21 +54,30 @@ export const validateUrl = (value, formatMessage, messages) => {
  * @param {Object} validationConfig - Configuration for tag validation
  * @returns {string} Error message if invalid, empty string if valid
  */
-export const validateMessageContent = (value, formatMessage, messages, validationConfig, isFullMode) => {
+export const validateMessageContent = (value, formatMessage, messages, validationConfig, isFullMode, restrictPersonalization) => {
   if (!value || value.trim() === '') {
     return formatMessage(messages.messageRequired);
   }
-  
+
   const validationResponse = validateTags({
     content: value,
     ...validationConfig,
     isFullMode,
   }) || {};
 
+  if (validationResponse?.unsupportedTags?.length) {
+    return formatMessage(globalMessages.unsupportedTagsValidationError, {
+      unsupportedTags: validationResponse.unsupportedTags.join(', '),
+    });
+  }
+
   if (validationResponse?.isBraceError) {
     return formatMessage(globalMessages.unbalanacedCurlyBraces);
   }
-  
+
+  if (restrictPersonalization && hasPersonalizationTags(value)) {
+    return formatMessage(messages.personalizationTokensErrorMessage);
+  }
+
   return '';
 };
-

package/v2Containers/WebPush/Create/utils/validation.test.js

@@ -44,6 +44,9 @@ describe('validation', () => {
     messageRequired: {
       defaultMessage: 'Message is required',
     },
+    personalizationTokensErrorMessage: {
+      defaultMessage: 'Personalization tags are not supported for anonymous customers',
+    },
   };
 
   beforeEach(() => {
@@ -113,6 +116,17 @@ describe('validation', () => {
       const result = validateTitle('  Valid Title  ', mockFormatMessage, mockMessages);
       expect(result).toBe('');
     });
+
+    it('should return personalization error when restrictPersonalization is true and title has personalization tags', () => {
+      const result = validateTitle(
+        'Hello {{name}}',
+        mockFormatMessage,
+        mockMessages,
+        true
+      );
+      expect(result).toBe('Personalization tags are not supported for anonymous customers');
+      expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.personalizationTokensErrorMessage);
+    });
   });
 
   describe('validateUrl', () => {
@@ -169,8 +183,10 @@ describe('validation', () => {
   describe('validateMessageContent', () => {
     const mockValidationConfig = {
       tagsParam: [],
+      injectedTagsParams: [],
       location: {},
       tagModule: '',
+      eventContextTags: [],
     };
 
     beforeEach(() => {
@@ -209,6 +225,17 @@ describe('validation', () => {
       });
     });
 
+    it('should return error message for unsupported tags', () => {
+      validateTags.mockReturnValue({
+        unsupportedTags: ['tag1', 'tag2'],
+      });
+      const result = validateMessageContent('Message with {tag1} and {tag2}', mockFormatMessage, mockMessages, mockValidationConfig);
+      expect(result).toBe('Unsupported tags: tag1, tag2');
+      expect(mockFormatMessage).toHaveBeenCalledWith(globalMessages.unsupportedTagsValidationError, {
+        unsupportedTags: 'tag1, tag2',
+      });
+    });
+
     it('should return error message for unbalanced curly braces', () => {
       validateTags.mockReturnValue({
         isBraceError: true,
@@ -218,11 +245,22 @@ describe('validation', () => {
       expect(mockFormatMessage).toHaveBeenCalledWith(globalMessages.unbalanacedCurlyBraces);
     });
 
+    it('should return error message for both unsupported tags and brace error (unsupported tags takes precedence)', () => {
+      validateTags.mockReturnValue({
+        unsupportedTags: ['tag1'],
+        isBraceError: true,
+      });
+      const result = validateMessageContent('Message with {tag1}', mockFormatMessage, mockMessages, mockValidationConfig);
+      expect(result).toBe('Unsupported tags: tag1');
+    });
+
     it('should pass validation config to validateTags', () => {
       const customConfig = {
         tagsParam: [{ id: 1, name: 'Tag1' }],
+        injectedTagsParams: [{ id: 2, name: 'Tag2' }],
         location: { query: { type: 'test' } },
         tagModule: 'custom',
+        eventContextTags: [{ id: 3, name: 'Tag3' }],
       };
       validateTags.mockReturnValue({});
       validateMessageContent('Valid message', mockFormatMessage, mockMessages, customConfig);
@@ -254,6 +292,20 @@ describe('validation', () => {
         ...mockValidationConfig,
       });
     });
+
+    it('should return personalization error when restrictPersonalization is true and message has personalization tags', () => {
+      validateTags.mockReturnValue({});
+      const result = validateMessageContent(
+        'Hello {{name}}',
+        mockFormatMessage,
+        mockMessages,
+        mockValidationConfig,
+        true,
+        true
+      );
+      expect(result).toBe('Personalization tags are not supported for anonymous customers');
+      expect(mockFormatMessage).toHaveBeenCalledWith(mockMessages.personalizationTokensErrorMessage);
+    });
   });
 });
 

package/v2Containers/Whatsapp/index.js

@@ -637,21 +637,22 @@ export const Whatsapp = (props) => {
         validateTags({
           content: contentData.join(""),
           tagsParam: tags,
+          injectedTagsParams: injectedTags,
           location,
           tagModule: getDefaultTags,
+          eventContextTags,
           isFullMode,
         }) || {};
+      const unsupportedTagsLengthCheck =
+        validationResponse?.unsupportedTags?.length > 0;
       if (type === HEADER_TEXT) {
         headerTagValidationResponse = validationResponse;
-        updateIsHeaderTagValidationError(validationResponse.isBraceError);
+        updateIsHeaderTagValidationError(unsupportedTagsLengthCheck);
       } else if (type === CAROUSEL_TEXT) {
-        return [
-          { fieldName: "carouselTagValidationErrMessage", value: validationResponse.isBraceError ? validationResponse : {} },
-          { fieldName: "carouselTagValidationErr", value: validationResponse.isBraceError },
-        ];
+        return [{fieldName: "carouselTagValidationErrMessage", value: validationResponse}, {fieldName: "carouselTagValidationErr", value: unsupportedTagsLengthCheck}];
       } else {
         tagValidationResponse = validationResponse;
-        updateIsTagValidationError(validationResponse.isBraceError);
+        updateIsTagValidationError(unsupportedTagsLengthCheck);
       }
     }
   };
@@ -2681,11 +2682,18 @@ const isAuthenticationTemplate = isEqual(templateCategory, WHATSAPP_CATEGORIES.a
     } else {
       validationResponse = tagValidationResponse;
     }
-    const { isBraceError } = validationResponse || {};
+    const { unsupportedTags = [], isBraceError } = validationResponse;
+
+    let tagError = "";
+    if (unsupportedTags.length > 0) {
+      tagError = formatMessage(globalMessages.unsupportedTagsValidationError, {
+        unsupportedTags,
+      });
+    }
     if (isBraceError) {
-      return <CapError>{formatMessage(globalMessages.unbalanacedCurlyBraces)}</CapError>;
+      tagError = formatMessage(globalMessages.unbalanacedCurlyBraces);
     }
-    return null;
+    return <CapError>{tagError}</CapError>;
   };
 
   const editModeContent = () => (

package/v2Containers/Zalo/index.js

@@ -270,15 +270,23 @@ export const Zalo = (props) => {
       validateTags({
         content: message,
         tagsParam: tags,
+        injectedTagsParams: injectedTags,
         location,
         tagModule: getDefaultTags,
+        eventContextTags,
         isFullMode,
       }) || {};
-    const { isBraceError } = tagValidationResponse;
+    const { unsupportedTags = [], isBraceError } = tagValidationResponse;
+    let tagError = '';
+    if (unsupportedTags.length > 0) {
+      tagError = formatMessage(globalMessages.unsupportedTagsValidationError, {
+        unsupportedTags,
+      });
+    }
     if (isBraceError) {
-      return formatMessage(globalMessages.unbalanacedCurlyBraces);
+      tagError = formatMessage(globalMessages.unbalanacedCurlyBraces);
     }
-    return '';
+    return tagError;
   };
 
   //this function is used for checking errror validation in this it validate tags error and length error