@capillarytech/creatives-library 8.0.129 → 8.0.131

package/services/tests/haptic-api.test.js

@@ -0,0 +1,387 @@
+import { uploadFile, createWhatsappTemplate } from '../api';
+
+// Mock fetch
+global.fetch = jest.fn();
+
+describe('HAPTIC API Integration Tests', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fetch.mockClear();
+  });
+
+  describe('uploadFile with HAPTIC parameters', () => {
+    it('should append HAPTIC-specific parameters to FormData', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        phoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      // Mock successful response
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      // Verify fetch was called
+      expect(fetch).toHaveBeenCalledTimes(1);
+
+      const fetchCall = fetch.mock.calls[0];
+      const url = fetchCall[0];
+      const options = fetchCall[1];
+
+      expect(url).toContain('/assets/whatsapp');
+      expect(options.method).toBe('POST');
+
+      // Verify FormData contains HAPTIC parameters
+      const formData = options.body;
+      expect(formData).toBeInstanceOf(FormData);
+
+      // Check that FormData contains the file
+      expect(formData.get('file')).not.toBeNull();
+
+      // Check that FormData contains HAPTIC parameters
+      expect(formData.get('source')).toBe('whatsapp');
+      expect(formData.get('wabaId')).toBe('waba-123');
+      expect(formData.get('accessToken')).toBe('haptic-token'); // Note: API converts access_token to accessToken
+      expect(formData.get('phoneId')).toBe('phone-456');
+      expect(formData.get('hostName')).toBe('hapticwhatsappbulk');
+    });
+
+    it('should handle missing HAPTIC parameters gracefully', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        // Missing parameters
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('source')).toBe('whatsapp');
+      expect(formData.get('wabaId')).toBe('undefined');
+      expect(formData.get('accessToken')).toBe('undefined');
+      expect(formData.get('phoneId')).toBe('undefined');
+      expect(formData.get('hostName')).toBe('undefined');
+    });
+
+    it('should handle undefined whatsappParams', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        // whatsappParams is undefined
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('file')).not.toBeNull();
+      // When whatsappParams is undefined, no whatsapp-specific fields are added
+      expect(formData.get('source')).toBeNull();
+      expect(formData.get('wabaId')).toBeNull();
+      expect(formData.get('accessToken')).toBeNull();
+      expect(formData.get('phoneId')).toBeNull();
+      expect(formData.get('hostName')).toBeNull();
+    });
+
+    it('should handle empty string parameters', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: '',
+        access_token: '',
+        phoneId: '',
+        hostName: '',
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('wabaId')).toBe('');
+      expect(formData.get('accessToken')).toBe('');
+      expect(formData.get('phoneId')).toBe('');
+      expect(formData.get('hostName')).toBe('');
+    });
+
+    it('should handle null parameters', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: null,
+        access_token: null,
+        phoneId: null,
+        hostName: null,
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('wabaId')).toBe('null');
+      expect(formData.get('accessToken')).toBe('null');
+      expect(formData.get('phoneId')).toBe('null');
+      expect(formData.get('hostName')).toBe('null');
+    });
+  });
+
+  describe('createWhatsappTemplate with HAPTIC payload', () => {
+    it('should create FormData with HAPTIC payload structure', () => {
+      const payload = {
+        name: 'HAPTIC Test Template',
+        category: 'MARKETING',
+        content: 'Hello {{1}}',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        PhoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+        hapticFileHandle: 'haptic-handle-123',
+        status: 'unsubmitted',
+      };
+
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      createWhatsappTemplate({ payload, gupshupMediaFile: mockFile });
+
+      const fetchCall = fetch.mock.calls[0];
+      const url = fetchCall[0];
+      const options = fetchCall[1];
+
+      expect(url).toContain('/templates/WHATSAPP');
+      expect(options.method).toBe('POST');
+
+      const formData = options.body;
+      expect(formData).toBeInstanceOf(FormData);
+
+      // Check payload JSON
+      const payloadJson = JSON.parse(formData.get('payload'));
+      expect(payloadJson).toEqual(payload);
+
+      // Check file
+      expect(formData.get('gupshupMediaFile')).toBe(mockFile);
+    });
+
+    it('should handle missing media file', () => {
+      const payload = {
+        name: 'HAPTIC Test Template',
+        category: 'MARKETING',
+        content: 'Hello {{1}}',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        PhoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      createWhatsappTemplate({ payload });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('payload')).toBe(JSON.stringify(payload));
+      expect(formData.get('gupshupMediaFile')).toBe('undefined');
+    });
+
+    it('should handle array of media files', () => {
+      const payload = {
+        name: 'HAPTIC Test Template',
+        category: 'MARKETING',
+        content: 'Hello {{1}}',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        PhoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      const mockFiles = [
+        new File(['test1'], 'test1.jpg', { type: 'image/jpeg' }),
+        new File(['test2'], 'test2.jpg', { type: 'image/jpeg' }),
+      ];
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      createWhatsappTemplate({ payload, gupshupMediaFile: mockFiles });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('gupshupMediaFile_0')).toBe(mockFiles[0]);
+      expect(formData.get('gupshupMediaFile_1')).toBe(mockFiles[1]);
+    });
+  });
+
+  describe('Parameter validation', () => {
+    it('should validate required HAPTIC parameters', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        phoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      // All required parameters should be present
+      expect(formData.get('wabaId')).toBe('waba-123');
+      expect(formData.get('accessToken')).toBe('haptic-token');
+      expect(formData.get('phoneId')).toBe('phone-456');
+      expect(formData.get('hostName')).toBe('hapticwhatsappbulk');
+    });
+
+    it('should handle mixed parameter types', () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        phoneId: '', // empty string
+        hostName: null, // null value
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 200,
+        json: () => Promise.resolve({ success: true }),
+      });
+
+      uploadFile({
+        file: mockFile,
+        assetType: 'whatsapp',
+        whatsappParams,
+      });
+
+      const fetchCall = fetch.mock.calls[0];
+      const formData = fetchCall[1].body;
+
+      expect(formData.get('wabaId')).toBe('waba-123');
+      expect(formData.get('accessToken')).toBe('haptic-token');
+      expect(formData.get('phoneId')).toBe('');
+      expect(formData.get('hostName')).toBe('null');
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle API errors gracefully', async () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        phoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      fetch.mockRejectedValueOnce(new Error('Network error'));
+
+      try {
+        await uploadFile({
+          file: mockFile,
+          assetType: 'whatsapp',
+          whatsappParams,
+        });
+      } catch (error) {
+        expect(error.message).toBe('Network error');
+      }
+    });
+
+    it('should handle HTTP error responses', async () => {
+      const mockFile = new File(['test content'], 'test.jpg', { type: 'image/jpeg' });
+      const whatsappParams = {
+        source: 'whatsapp',
+        wabaId: 'waba-123',
+        access_token: 'haptic-token',
+        phoneId: 'phone-456',
+        hostName: 'hapticwhatsappbulk',
+      };
+
+      fetch.mockResolvedValueOnce({
+        status: 400,
+        statusText: 'Bad Request',
+        json: () => Promise.resolve({ error: 'Invalid parameters' }),
+      });
+
+      try {
+        await uploadFile({
+          file: mockFile,
+          assetType: 'whatsapp',
+          whatsappParams,
+        });
+      } catch (error) {
+        expect(error.status).toBe(400);
+        expect(error.statusText).toBe('Bad Request');
+      }
+    });
+  });
+});

package/utils/createMobilePushPayload.js

@@ -0,0 +1,322 @@
+// Utility to create the Mobile Push payload for rich media, with validation
+import { DEEP_LINK } from "../v2Components/CapInAppCTA/constants";
+import { EXTERNAL_URL } from "../v2Components/CapMpushCTA/constants";
+import {
+  IMAGE, VIDEO, GIF, CAROUSEL, BIG_TEXT, BIG_PICTURE,
+  MANUAL_CAROUSEL,
+  AUTO_CAROUSEL,
+  FILMSTRIP_CAROUSEL,
+  ANDROID,
+  IOS,
+} from "../v2Containers/MobilePushNew/constants";
+import messages from '../v2Containers/MobilePushNew/messages';
+
+/**
+ * Constructs the payload for Mobile Push, supporting both legacy and rich media as per backend contract.
+ * - Trims and validates templateName
+ * - Handles legacy and rich media (VIDEO, GIF, CAROUSEL)
+ * - Supports platform-specific content (Android/iOS)
+ * - Handles CTA and custom fields
+ * @param {Object} params - The parameters for creating the payload
+ * @param {string} params.templateName - The name of the template
+ * @param {Object} params.androidContent - Android-specific content
+ * @param {Object} params.iosContent - iOS-specific content
+ * @param {Object} params.imageSrc - Image source URLs
+ * @param {Object} params.mpushVideoSrcAndPreview - Video source and preview URLs
+ * @param {Object} params.accountData - Account data for the payload
+ * @param {boolean} params.sameContent - Whether content is shared between platforms
+ * @param {Object} params.options - Additional options
+ * @param {Object} params.intl - Internationalization object for messages
+ */
+const createMobilePushPayload = ({
+  templateName,
+  androidContent,
+  iosContent,
+  imageSrc = {},
+  mpushVideoSrcAndPreview = {},
+  accountData,
+  sameContent = false,
+  options = {},
+  intl,
+}) => {
+  // Platform support checks must be at the top
+  const isAndroidSupported = accountData?.configs?.android === '1';
+  const isIosSupported = accountData?.configs?.ios === '1';
+
+  const {
+    accountId: accountIdFromAccountData, id, licenseCode: licenseCodeFromAccountData, sourceAccountIdentifier, sourceType: sourceTypeFromAccountData, sourceTypeName,
+  } = accountData || {};
+  // Validate account data
+  const accountId = accountIdFromAccountData || id;
+  const licenseCode = licenseCodeFromAccountData || sourceAccountIdentifier;
+  const sourceType = sourceTypeFromAccountData || sourceTypeName;
+
+  if (!accountId || !licenseCode || !sourceType) {
+    throw new Error(intl.formatMessage(messages.accountDataRequiredError));
+  }
+
+  // Validate template name
+  const trimmedTemplateName = templateName?.trim();
+  if (!trimmedTemplateName) {
+    throw new Error(intl.formatMessage(messages.templateNameEmptyError));
+  }
+
+  // Validate content
+  if (isAndroidSupported && (!androidContent?.title || !androidContent?.message)) {
+    throw new Error(intl.formatMessage(messages.contentValidationError, { platform: 'Android' }));
+  }
+  if (isIosSupported && (!iosContent?.title || !iosContent?.message)) {
+    throw new Error(intl.formatMessage(messages.contentValidationError, { platform: 'iOS' }));
+  }
+
+  // Ensure imageSrc has the required properties
+  const safeImageSrc = {
+    androidImageSrc: imageSrc?.androidImageSrc || '',
+    iosImageSrc: imageSrc?.iosImageSrc || '',
+  };
+
+  // Ensure mpushVideoSrcAndPreview has the required properties
+  const safeMpushVideoSrcAndPreview = {
+    mpushVideoSrc: mpushVideoSrcAndPreview?.mpushVideoSrc || '',
+    mpushVideoPreviewImg: mpushVideoSrcAndPreview?.mpushVideoPreviewImg || '',
+    duration: mpushVideoSrcAndPreview?.duration || 0,
+  };
+
+  // Build the payload
+  const payload = {
+    name: trimmedTemplateName,
+    definition: {
+      accountId,
+      licenseCode,
+      sourceType,
+      sameContent,
+      mode: options?.mode,
+    },
+    versions: {
+      base: {},
+    },
+  };
+
+  // Build Android content
+  if (isAndroidSupported) {
+    payload.versions.base.ANDROID = buildPlatformContent(
+      androidContent,
+      safeImageSrc.androidImageSrc,
+      safeMpushVideoSrcAndPreview,
+      ANDROID,
+    );
+  }
+
+  // Build iOS content
+  if (isIosSupported) {
+    payload.versions.base.IOS = buildPlatformContent(
+      iosContent,
+      safeImageSrc.iosImageSrc,
+      safeMpushVideoSrcAndPreview,
+      IOS,
+    );
+  }
+
+  return payload;
+};
+
+/**
+ * Builds platform-specific content for the payload
+ * @param {Object} content - Platform content (Android/iOS)
+ * @param {string} imageSrc - Image source URL
+ * @param {Object} mpushVideoSrcAndPreview - Video source and preview URLs
+ * @param {string} platform - Platform (ANDROID/IOS)
+ * @returns {Object} Platform-specific content
+ */
+function buildPlatformContent(content, imageSrc, mpushVideoSrcAndPreview, platform) {
+  const {
+    title = '',
+    message = '',
+    expandableDetails = {},
+    actionOnClick,
+    linkType,
+    deepLinkValue,
+    externalLinkValue,
+  } = content || {};
+
+  const platformContent = {
+    title,
+    message,
+    expandableDetails: { ...expandableDetails },
+    custom: buildCustomFields(content),
+  };
+
+  // Handle CTA
+  if (actionOnClick) {
+    platformContent.cta = {
+      type: linkType === DEEP_LINK ? DEEP_LINK : EXTERNAL_URL,
+      actionLink: linkType === DEEP_LINK ? deepLinkValue : externalLinkValue,
+    };
+  }
+
+  // Handle media types
+  const style = content?.mediaType || expandableDetails?.style;
+
+  // Handle BIG_PICTURE media type
+  if (style === BIG_PICTURE || style === IMAGE) {
+    platformContent.expandableDetails.style = BIG_PICTURE;
+    platformContent.expandableDetails.image = imageSrc;
+  } else if (style === VIDEO) { // Handle VIDEO media type
+    platformContent.expandableDetails.style = VIDEO;
+    platformContent.expandableDetails.media = [{
+      url: mpushVideoSrcAndPreview.mpushVideoSrc || (content?.mediaList?.[0]?.url || ''),
+      text: content?.mediaList?.[0]?.text || '',
+      type: VIDEO,
+    }];
+  } else if (style === GIF) { // Handle GIF media type
+    platformContent.expandableDetails.style = GIF;
+    if (content?.mediaList?.[0]) {
+      // If mediaList exists, use it and preserve the original type
+      const { url = '', text = '', type = GIF } = content.mediaList[0];
+      platformContent.expandableDetails.media = [{
+        url,
+        text,
+        type: type.toLowerCase(),
+      }];
+    } else {
+      // If no mediaList but mpushVideoSrc exists, convert to VIDEO
+      platformContent.expandableDetails.media = [{
+        url: mpushVideoSrcAndPreview.mpushVideoSrc,
+        text: '',
+        type: GIF, // Backend expects GIF type for GIFs
+      }];
+    }
+  } else if ([CAROUSEL, MANUAL_CAROUSEL, AUTO_CAROUSEL, FILMSTRIP_CAROUSEL].includes(style)) { // Handle CAROUSEL media types
+    platformContent.expandableDetails.style = MANUAL_CAROUSEL;
+
+    // Handle carouselData
+    if (content?.carouselData?.length > 0) {
+      platformContent.expandableDetails.carouselData = content.carouselData.map((card) => {
+        const {
+          mediaType,
+          imageUrl,
+          videoSrc,
+          buttons,
+        } = card || {};
+
+        return {
+          mediaType: mediaType || IMAGE.toLowerCase(),
+          imageUrl: imageUrl || '',
+          videoSrc: videoSrc || '',
+          buttons: buttons ? buttons.map((button) => {
+            const { linkType: buttonLinkType, deepLinkKeys, deepLinkValue: buttonDeepLinkValue } = button || {};
+            if (buttonLinkType === DEEP_LINK && deepLinkKeys && buttonDeepLinkValue) {
+              const deepLinkKeysArray = Array.isArray(deepLinkKeys) ? deepLinkKeys : [deepLinkKeys];
+              const updatedDeepLinkValue = appendDeepLinkKeysToUrl(buttonDeepLinkValue, deepLinkKeysArray);
+
+              return {
+                ...button,
+                deepLinkValue: updatedDeepLinkValue,
+              };
+            }
+            return button;
+          }) : [],
+        };
+      });
+    }
+
+    // Handle mediaList
+    if (content?.mediaList && Array.isArray(content.mediaList) && content.mediaList.length > 0) {
+      platformContent.expandableDetails.media = content.mediaList.map((media) => {
+        const {
+          url,
+          text,
+          type,
+        } = media || {};
+
+        return {
+          url,
+          text: text || '',
+          type,
+        };
+      });
+    }
+  } else { // Handle BIG_TEXT media type (default)
+    platformContent.expandableDetails.style = BIG_TEXT;
+    platformContent.expandableDetails.message = message;
+  }
+
+  // Handle GIF media type
+  if (content?.mediaType === GIF) {
+    platformContent.expandableDetails = {
+      media: [{
+        url: mpushVideoSrcAndPreview?.mpushVideoSrc || (content?.mediaList?.[0]?.url || ''),
+        text: content?.mediaList?.[0]?.text || '',
+        type: GIF,
+      }],
+    };
+  }
+
+  // iOS-specific handling
+  if (platform === IOS) {
+    // iOS always needs a ctas array in expandableDetails
+    platformContent.expandableDetails.ctas = platformContent.expandableDetails.ctas || [];
+  }
+
+  return platformContent;
+}
+
+/**
+ * Builds custom fields array from content
+ * @param {Object} content - Platform content (Android/iOS)
+ * @returns {Array} Array of custom fields
+ */
+function buildCustomFields(content) {
+  let customFields = [];
+  const { custom = {} } = content || {};
+  // If content.custom is already an array, use it as base
+  if (Array.isArray(custom)) {
+    customFields = [...custom];
+  } else if (custom && typeof custom === 'object') {
+    // If it's an object, map to array
+    customFields = Object.entries(custom).map(([key, value]) => ({ key, value }));
+  }
+  const { deepLinkKeysValue, deepLinkValue, linkType } = custom || {};
+  // Add deepLinkKeys to custom fields if it exists
+  if (deepLinkKeysValue && linkType === DEEP_LINK) {
+    if (Array.isArray(deepLinkKeysValue)) {
+      // Handle array of deep link keys
+      deepLinkKeysValue.forEach((key) => {
+        if (key) {
+          customFields.push({
+            key,
+            value: deepLinkValue,
+          });
+        }
+      });
+    } else {
+      // Handle single deep link key
+      customFields.push({
+        key: deepLinkKeysValue,
+        value: deepLinkValue,
+      });
+    }
+  }
+
+  return customFields;
+}
+
+/**
+ * Appends deep link keys to URL
+ * @param {string} url - Base URL
+ * @param {Array} keys - Deep link keys
+ * @returns {string} URL with appended keys
+ */
+function appendDeepLinkKeysToUrl(url, keys) {
+  if (!url || !keys || !Array.isArray(keys) || keys?.length === 0) return url;
+
+  const separator = url.includes('?') ? '&' : '?';
+  const validKeys = keys.filter((key) => typeof key === 'string' && key?.length > 0);
+  if (validKeys?.length === 0) return url;
+
+  const keyParams = validKeys.map((key) => `${key}={{${key}}}`).join('&');
+
+  return `${url}${separator}${keyParams}`;
+}
+
+export default createMobilePushPayload;