cap-creatives-ui 8.0.280 → 8.0.321

package/.github/workflows/pr-title-check.yml

@@ -0,0 +1,88 @@
+name: PR Title Check for JIRA Ticket
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+    branches:
+      - main
+      - master
+
+jobs:
+  check-pr-title:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    steps:
+      - name: Fetch current PR title
+        id: pr-title
+        run: |
+          set -euo pipefail
+          
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          if [ -z "${PR_NUMBER}" ]; then
+            echo "❌ Error: PR number is not available"
+            exit 1
+          fi
+          
+          echo "Fetching PR #${PR_NUMBER} details..."
+          API_RESPONSE=$(curl -s -w "\n%{http_code}" \
+            -H "Authorization: Bearer ${{ github.token }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/pulls/${PR_NUMBER}")
+          
+          HTTP_CODE=$(echo "$API_RESPONSE" | tail -n1)
+          API_BODY=$(echo "$API_RESPONSE" | sed '$d')
+          
+          if [ "${HTTP_CODE}" != "200" ]; then
+            echo "❌ Error: Failed to fetch PR details (HTTP ${HTTP_CODE})"
+            echo "Response: ${API_BODY}"
+            exit 1
+          fi
+          
+          PR_TITLE=$(echo "$API_BODY" | python3 -c "
+          import sys, json
+          try:
+              data = json.load(sys.stdin)
+              title = data.get('title', '')
+              if not title:
+                  print('ERROR: PR title is empty', file=sys.stderr)
+                  sys.exit(1)
+              print(title)
+          except json.JSONDecodeError as e:
+              print(f'ERROR: Invalid JSON response: {e}', file=sys.stderr)
+              sys.exit(1)
+          except KeyError as e:
+              print(f'ERROR: Missing field in response: {e}', file=sys.stderr)
+              sys.exit(1)
+          except Exception as e:
+              print(f'ERROR: Unexpected error: {e}', file=sys.stderr)
+              sys.exit(1)
+          ")
+          
+          if [ -z "${PR_TITLE}" ]; then
+            echo "❌ Error: PR title is empty"
+            exit 1
+          fi
+          
+          echo "title=${PR_TITLE}" >> $GITHUB_OUTPUT
+          echo "Current PR title: ${PR_TITLE}"
+      - name: Validate PR title contains CAP-xxxx
+        run: |
+          set -euo pipefail
+          
+          PR_TITLE="${{ steps.pr-title.outputs.title }}"
+          
+          if [ -z "${PR_TITLE}" ]; then
+            echo "❌ Error: PR title is not available from previous step"
+            exit 1
+          fi
+          
+          if ! echo "${PR_TITLE}" | grep -qE 'CAP-[0-9]+'; then
+            echo "❌ PR title must contain a JIRA ticket id like CAP-1234"
+            echo "Current PR title: ${PR_TITLE}"
+            exit 1
+          else
+            echo "✅ PR title is valid: ${PR_TITLE}"
+          fi

package/app/constants/unified.js

@@ -43,8 +43,8 @@ export const HOSPITALITY_BASED_SCOPE = 'HOSPITALITY_BASED_SCOPE';
 export const REGISTRATION_CUSTOM_FIELD = 'Registration custom fields';
 export const GIFT_CARDS = 'GIFT_CARDS';
 export const PROMO_ENGINE = 'PROMO_ENGINE';
-export const LIQUID_SUPPORT = 'ENABLE_LIQUID_SUPPORT';
 export const ENABLE_NEW_MPUSH = 'ENABLE_NEW_MPUSH';
+export const ENABLE_NEW_EDITOR_FLOW_INAPP = 'ENABLE_NEW_EDITOR_FLOW_INAPP';
 export const SUPPORT_CK_EDITOR = 'SUPPORT_CK_EDITOR';
 export const CUSTOM_TAG = 'CustomTagMessage';
 export const CUSTOMER_EXTENDED_FIELD = 'Customer extended fields';
@@ -60,6 +60,7 @@ export const AI_CONTENT_BOT_DISABLED = 'AI_CONTENT_BOT_DISABLED';
 export const AI_DOCUMENTATION_BOT_ENABLED = 'AI_DOCUMENTATION_BOT_ENABLED';
 export const ENABLE_NEW_LEFT_NAVIGATION = 'ENABLE_NEW_LEFT_NAVIGATION';
 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 = [
@@ -150,9 +151,28 @@ export const BADGES_ENROLL = 'BADGES_ENROLL';
 export const BADGES_ISSUE = 'BADGES_ISSUE';
 export const CUSTOMER_BARCODE_TAG = 'customer_barcode';
 export const COPY_OF = 'Copy of';
+export const UNSUBSCRIBE_TAG = 'unsubscribe';
+/** Whitespace-tolerant check for {{ unsubscribe }}-style tag in content. */
+export const UNSUBSCRIBE_TAG_REGEX = new RegExp(`\\{\\{\\s*${UNSUBSCRIBE_TAG}\\s*\\}\\}`);
+/** Matches {{ ... }} and captures the inner tag content (for scanning content for tags). */
+export const TAG_CONTENT_REGEX = /{{([^}]+)}}/g;
 export const ENTRY_TRIGGER_TAG_REGEX = /\bentryTrigger\.\w+(?:\.\w+)?(?:\(\w+\))?/g;
 export const SKIP_TAGS_REGEX_GROUPS = ["dynamic_expiry_date_after_\\d+_days.FORMAT_\\d", "unsubscribe\\(#[a-zA-Z\\d]{6}\\)", "Link_to_[a-zA-Z]", "SURVEY.*.TOKEN", "^[A-Za-z].*\\([a-zA-Z\\d]*\\)", "referral_unique_(code|url).*userid"];
 
+// --- Template variable tokens (`{{var}}`, DLT `{#var#}`) ---
+/** Global: all `{{…}}` placeholders in a string. */
+export const DEFAULT_MUSTACHE_VAR_REGEX = /\{\{[^}]+\}\}/g;
+/** Global: `{{…}}` or DLT `{#…#}` tokens (SMS combined mode). */
+export const COMBINED_SMS_TEMPLATE_VAR_REGEX = /\{\{[^}]+\}\}|\{\#[^#]*\#\}/g;
+/** Full-string check: one mustache token. */
+export const MUSTACHE_VAR_TOKEN_FULL_STRING_REGEX = /^\{\{[^}]+\}\}$/;
+/** Full-string check: one DLT hash token. */
+export const DLT_HASH_VAR_TOKEN_FULL_STRING_REGEX = /^\{\#[^#]*\#\}$/;
+/** Global with capture group: inner name inside `{{name}}`. */
+export const MUSTACHE_VAR_NAME_CAPTURE_REGEX = /\{\{([^}]+)\}\}/g;
+/** Global with capture group: inner body inside `{#body#}`. */
+export const DLT_VAR_BODY_CAPTURE_REGEX = /\{\#([^#]*)\#\}/g;
+
 export const GET_TRANSLATION_MAPPED = {
   'en': 'en-US',
   'zh-cn': 'zh',

package/app/containers/App/constants.js

@@ -11,7 +11,6 @@ export const HOSPITALITY_BASED_SCOPE = 'HOSPITALITY_BASED_SCOPE';
 export const REGISTRATION_CUSTOM_FIELD = 'Registration custom fields';
 export const GIFT_CARDS = 'GIFT_CARDS';
 export const PROMO_ENGINE = 'PROMO_ENGINE';
-export const LIQUID_SUPPORT = 'ENABLE_LIQUID_SUPPORT';
 export const CUSTOM_TAG = 'CustomTagMessage';
 export const CUSTOMER_EXTENDED_FIELD = 'Customer extended fields';
 export const EXTENDED_TAG = 'ExtendedTagMessage';

package/app/containers/Login/test/index.test.js

@@ -0,0 +1,123 @@
+/**
+ * Test suite for Login container
+ */
+import React from 'react';
+import { shallow, mount } from 'enzyme';
+import { Provider } from 'react-redux';
+import { configureStore } from '@capillarytech/vulcan-react-sdk/utils';
+import { fromJS } from 'immutable';
+import { Router } from 'react-router-dom';
+import createHistory from 'history/createHashHistory';
+import { IntlProvider } from 'react-intl';
+import { Login } from '../index';
+import initialReducer from '../../../initialReducer';
+
+const history = createHistory();
+
+describe('Login Container', () => {
+  let store;
+  let props;
+
+  beforeEach(() => {
+    store = configureStore(
+      {
+        cap: fromJS({
+          token: '',
+          login_progress: false,
+          fetching_userdata: false,
+          isError: false,
+        }),
+      },
+      initialReducer,
+      history,
+    );
+
+    props = {
+      Login: {
+        token: '',
+        login_progress: false,
+        fetching_userdata: false,
+        isError: false,
+      },
+      actions: {
+        authenticate: jest.fn(),
+      },
+      replace: jest.fn(),
+      location: {
+        query: {},
+      },
+      router: {
+        push: jest.fn(),
+        go: jest.fn(),
+      },
+    };
+  });
+
+  it('should render without crashing', () => {
+    const wrapper = shallow(<Login {...props} />);
+    expect(wrapper).toBeDefined();
+  });
+
+  it('should render the login container div', () => {
+    const wrapper = shallow(<Login {...props} />);
+    expect(wrapper.find('.login-container')).toHaveLength(1);
+  });
+
+  it('should render Helmet with page title', () => {
+    const wrapper = mount(
+      <Provider store={store}>
+        <Router history={history}>
+          <IntlProvider locale="en">
+            <Login {...props} />
+          </IntlProvider>
+        </Router>
+      </Provider>,
+    );
+    expect(wrapper.find('Helmet')).toBeDefined();
+  });
+
+  it('should apply opacity-class when fetching_userdata is true', () => {
+    const propsWithFetching = {
+      ...props,
+      Login: {
+        ...props.Login,
+        fetching_userdata: true,
+      },
+    };
+
+    const wrapper = mount(
+      <Provider store={store}>
+        <Router history={history}>
+          <IntlProvider locale="en">
+            <Login {...propsWithFetching} />
+          </IntlProvider>
+        </Router>
+      </Provider>,
+    );
+
+    const mainDiv = wrapper.find('.opacity-class');
+    expect(mainDiv).toHaveLength(1);
+  });
+
+  it('should not apply opacity-class when fetching_userdata is false', () => {
+    const wrapper = mount(
+      <Provider store={store}>
+        <Router history={history}>
+          <IntlProvider locale="en">
+            <Login {...props} />
+          </IntlProvider>
+        </Router>
+      </Provider>,
+    );
+
+    const mainDiv = wrapper.find('.opacity-class');
+    expect(mainDiv).toHaveLength(0);
+  });
+
+  it('should have propTypes validation', () => {
+    expect(Login.propTypes).toBeDefined();
+    expect(Login.propTypes.actions).toBeDefined();
+    expect(Login.propTypes.Login).toBeDefined();
+    expect(Login.propTypes.replace).toBeDefined();
+  });
+});

package/app/containers/Login/test/selectors.test.js

@@ -0,0 +1,165 @@
+/**
+ * Test suite for Login selectors
+ */
+import { fromJS } from 'immutable';
+import makeSelectLogin, { selectLoginDomain } from '../selectors';
+
+describe('Login Selectors', () => {
+  describe('selectLoginDomain', () => {
+    it('should select the cap domain from state', () => {
+      const mockState = fromJS({
+        cap: {
+          token: 'test-token',
+          user: 'testuser',
+        },
+      });
+
+      const selector = selectLoginDomain();
+      const result = selector(mockState);
+
+      expect(result).toBeDefined();
+      expect(result.get('token')).toBe('test-token');
+      expect(result.get('user')).toBe('testuser');
+    });
+
+    it('should return the cap domain as an Immutable Map', () => {
+      const mockState = fromJS({
+        cap: {
+          login_progress: false,
+          fetching_userdata: false,
+        },
+      });
+
+      const selector = selectLoginDomain();
+      const result = selector(mockState);
+
+      expect(result.toJS).toBeDefined(); // Verify it's Immutable
+      expect(result.get('login_progress')).toBe(false);
+    });
+  });
+
+  describe('makeSelectLogin', () => {
+    it('should convert Immutable state to plain JavaScript object', () => {
+      const mockState = fromJS({
+        cap: {
+          token: 'test-token',
+          login_progress: false,
+          fetching_userdata: false,
+        },
+      });
+
+      const selector = makeSelectLogin();
+      const result = selector(mockState);
+
+      expect(typeof result).toBe('object');
+      expect(result.token).toBe('test-token');
+      expect(result.login_progress).toBe(false);
+    });
+
+    it('should return a plain object (not Immutable Map)', () => {
+      const mockState = fromJS({
+        cap: {
+          data: [1, 2, 3],
+        },
+      });
+
+      const selector = makeSelectLogin();
+      const result = selector(mockState);
+
+      expect(result.toJS).toBeUndefined(); // Not an Immutable Map
+      expect(Array.isArray(result.data)).toBe(true);
+    });
+
+    it('should create a new selector instance with memoization', () => {
+      const mockState = fromJS({
+        cap: {
+          token: 'test-token',
+        },
+      });
+
+      const selector1 = makeSelectLogin();
+      const selector2 = makeSelectLogin();
+
+      const result1 = selector1(mockState);
+      const result2 = selector2(mockState);
+
+      // Different selector instances should produce equal results
+      expect(result1).toEqual(result2);
+    });
+
+    it('should include all cap state properties in result', () => {
+      const mockState = fromJS({
+        cap: {
+          token: 'test-token',
+          login_progress: true,
+          fetching_userdata: false,
+          isError: true,
+          user: 'john',
+          email: 'john@example.com',
+        },
+      });
+
+      const selector = makeSelectLogin();
+      const result = selector(mockState);
+
+      expect(result.token).toBe('test-token');
+      expect(result.login_progress).toBe(true);
+      expect(result.fetching_userdata).toBe(false);
+      expect(result.isError).toBe(true);
+      expect(result.user).toBe('john');
+      expect(result.email).toBe('john@example.com');
+    });
+
+    it('should handle empty cap state', () => {
+      const mockState = fromJS({
+        cap: {},
+      });
+
+      const selector = makeSelectLogin();
+      const result = selector(mockState);
+
+      expect(result).toEqual({});
+    });
+
+    it('should memoize results (reselect behavior)', () => {
+      const mockState = fromJS({
+        cap: {
+          token: 'test-token',
+        },
+      });
+
+      const selector = makeSelectLogin();
+
+      // Call with same state object multiple times
+      const result1 = selector(mockState);
+      const result2 = selector(mockState);
+
+      // Results should be the same reference (memoized)
+      expect(result1).toBe(result2);
+    });
+
+    it('should recompute when cap state changes', () => {
+      const selector = makeSelectLogin();
+
+      const mockState1 = fromJS({
+        cap: {
+          token: 'token1',
+        },
+      });
+
+      const mockState2 = fromJS({
+        cap: {
+          token: 'token2',
+        },
+      });
+
+      const result1 = selector(mockState1);
+      const result2 = selector(mockState2);
+
+      // Results should be different when state changes
+      expect(result1).not.toBe(result2);
+      expect(result1.token).toBe('token1');
+      expect(result2.token).toBe('token2');
+    });
+  });
+});

package/app/initialState.js

@@ -14,9 +14,7 @@ export default {
     metaEntities: {
       tags: [],
       layouts: [],
-      tagLookupMap: {},
     },
-    liquidTags: [],
     fetchingLiquidTags: false,
     fetchingSchema: true,
     fetchingSchemaError: '',

package/app/services/api.js

@@ -334,6 +334,12 @@ export const getTemplateDetails = async ({id, channel}) => {
   return { ...compressedTemplatesData, response: decompressData};
 };
 
+export const getDomainProperties = (channels, orgUnitId) => {
+  const queryString = channels?.map((channel) => `channel=${channel?.toUpperCase()}`)?.join('&');
+  const url = `${CAMPAIGNS_API_ORG_ENDPOINT}/meta/domainProperties?${queryString}`;
+  return request(url, getAPICallObject('GET', null, false, true, orgUnitId));
+};
+
 export const getMediaDetails = async ({ id }) => {
   const url = `${API_ENDPOINT}/media/${id}`;
   return request(url, getAPICallObject('GET'));

package/app/services/tests/api.test.js

@@ -1,5 +1,6 @@
 import {
   getSenderDetails,
+  getDomainProperties,
   uploadFile,
   getCdnTransformationConfig,
   createWhatsappTemplate,
@@ -52,6 +53,12 @@ describe('getSenderDetails -- Test with valid responses', () => {
     expect(getSenderDetails('WHATSAPP', -1)).toEqual(Promise.resolve()));
 });
 
+describe('getDomainProperties -- Test with valid responses', () => {
+  it('Should return correct response', () => {
+    expect(getDomainProperties(['SMS', 'EMAIL'], null)).toEqual(Promise.resolve());
+  });
+});
+
 describe('getCdnTransformationConfigs -- Test with valid responses', () => {
   it('Should return correct response', () =>
     expect(getCdnTransformationConfig()).toEqual(Promise.resolve()));

package/app/services/tests/getSchema.test.js

@@ -0,0 +1,95 @@
+/**
+ * Test suite for getSchema
+ */
+import getSchema from '../getSchema';
+
+describe('getSchema', () => {
+  it('should return a promise when called', () => {
+    const result = getSchema('sms');
+    expect(result instanceof Promise).toBe(true);
+  });
+
+  it('should return SMS schema when channel is "sms"', () => {
+    const result = getSchema('sms');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return SMS schema when channel is "SMS" (uppercase)', () => {
+    const result = getSchema('SMS');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return EMAIL schema when channel is "email"', () => {
+    const result = getSchema('email');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return EMAIL schema when channel is "EMAIL" (uppercase)', () => {
+    const result = getSchema('EMAIL');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return MOBILE_PUSH schema when channel is "mobile_push"', () => {
+    const result = getSchema('mobile_push');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return MOBILE_PUSH schema when channel is "MOBILE_PUSH" (uppercase)', () => {
+    const result = getSchema('MOBILE_PUSH');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return WECHAT schema when channel is "wechat"', () => {
+    const result = getSchema('wechat');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return WECHAT schema when channel is "WECHAT" (uppercase)', () => {
+    const result = getSchema('WECHAT');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return SMS schema (default) when channel is unknown', () => {
+    const result = getSchema('unknown_channel');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should return SMS schema (default) when channel is "whatsapp"', () => {
+    const result = getSchema('whatsapp');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should handle mixed case channel names', () => {
+    const result = getSchema('SmS');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+
+  it('should handle whitespace in channel names', () => {
+    const result = getSchema(' sms ');
+    return result.then((module) => {
+      expect(module).toBeDefined();
+    });
+  });
+});

package/app/utils/common.js

@@ -16,15 +16,17 @@ import {
   REGISTRATION_CUSTOM_FIELD,
   JP_LOCALE_HIDE_FEATURE,
   ENABLE_CUSTOMER_BARCODE_TAG,
+  AI_CONTENT_BOT_DISABLED,
   BADGES_UI_ENABLED,
   BADGES_ENROLL,
   EMAIL_UNSUBSCRIBE_TAG_MANDATORY,
   BADGES_ISSUE,
   ENABLE_WECHAT,
   ENABLE_WEBPUSH,
-  LIQUID_SUPPORT,
   SUPPORT_CK_EDITOR,
-  ENABLE_NEW_MPUSH
+  ENABLE_NEW_MPUSH,
+  ENABLE_NEW_EDITOR_FLOW_INAPP,
+  SUPPORT_ENGAGEMENT_MODULE,
 } from '../constants/unified';
 import { apiMessageFormatHandler } from './commonUtils';
 
@@ -91,16 +93,14 @@ export const hasPromoFeature = Auth.hasFeatureAccess.bind(
   null,
   PROMO_ENGINE,
 );
-
-export const hasLiquidSupportFeature = Auth.hasFeatureAccess.bind(
-  null,
-  LIQUID_SUPPORT,
-);
-
 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,
@@ -132,7 +132,16 @@ export const hasCustomerBarcodeFeatureEnabled = Auth.hasFeatureAccess.bind(
   ENABLE_CUSTOMER_BARCODE_TAG,
 );
 
-export const isEmailUnsubscribeTagMandatory = Auth.hasFeatureAccess.bind(
+export const isAiContentBotDisabled = Auth.hasFeatureAccess.bind(
+  null,
+  AI_CONTENT_BOT_DISABLED,
+);
+
+// Note: The "EMAIL_UNSUBSCRIBE_TAG_MANDATORY" feature flag determines if the Unsubscribe tag in email is optional. 
+// When this flag is enabled for an org, the Unsubscribe tag is NOT mandatory in the email flow.
+// This is as per the requirement in the tech doc:
+// https://capillarytech.atlassian.net/wiki/spaces/CAM/pages/3941662838/Remove+mandate+for+Unsubscribe+tag+in+email+flow
+export const isEmailUnsubscribeTagOptional = Auth.hasFeatureAccess.bind(
   null,
   EMAIL_UNSUBSCRIBE_TAG_MANDATORY,
 );
@@ -142,6 +151,11 @@ export const hasNewMobilePushFeatureEnabled = Auth.hasFeatureAccess.bind(
   ENABLE_NEW_MPUSH,
 );
 
+export const hasNewEditorFlowInAppEnabled = Auth.hasFeatureAccess.bind(
+  null,
+  ENABLE_NEW_EDITOR_FLOW_INAPP,
+);
+
 //filtering tags based on scope
 export const filterTags = (tagsToFilter, tagsList) => tagsList?.filter(
     (tag) => !tagsToFilter?.includes(tag?.definition?.value)