@capillarytech/creatives-library 8.0.291 → 8.0.292

package/v2Components/CommonTestAndPreview/tests/sagas.test.js

@@ -25,9 +25,17 @@ import {
   watchFetchTestGroups,
   watchCreateMessageMeta,
   watchGetPrefilledValues,
+  getSenderDetailsSaga,
+  getWeCrmAccountsSaga,
+  watchGetSenderDetails,
+  watchGetWeCrmAccounts,
   commonTestAndPreviewSaga,
 } from '../sagas';
 import * as Api from '../../../services/api';
+jest.mock('../DeliverySettings/utils/parseSenderDetailsResponse', () => ({
+  parseSenderDetailsResponse: jest.fn((channel, response) => ({ domains: response?.entity?.[channel] || [] })),
+}));
+import { parseSenderDetailsResponse } from '../DeliverySettings/utils/parseSenderDetailsResponse';
 import {
   SEARCH_CUSTOMERS_SUCCESS,
   SEARCH_CUSTOMERS_FAILURE,
@@ -45,6 +53,10 @@ import {
   CREATE_MESSAGE_META_FAILURE,
   GET_PREFILLED_VALUES_SUCCESS,
   GET_PREFILLED_VALUES_FAILURE,
+  GET_SENDER_DETAILS_SUCCESS,
+  GET_SENDER_DETAILS_FAILURE,
+  GET_WECRM_ACCOUNTS_SUCCESS,
+  GET_WECRM_ACCOUNTS_FAILURE,
 } from '../constants';
 
 describe('CommonTestAndPreview Sagas', () => {
@@ -1694,6 +1706,137 @@ describe('CommonTestAndPreview Sagas', () => {
       );
       expect(generator.next().done).toBe(true);
     });
+
+    it('should watch for GET_SENDER_DETAILS_REQUESTED', () => {
+      const generator = watchGetSenderDetails();
+      expect(generator.next().value).toEqual(
+        takeLatest('app/CommonTestAndPreview/GET_SENDER_DETAILS_REQUESTED', getSenderDetailsSaga)
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should watch for GET_WECRM_ACCOUNTS_REQUESTED', () => {
+      const generator = watchGetWeCrmAccounts();
+      expect(generator.next().value).toEqual(
+        takeLatest('app/CommonTestAndPreview/GET_WECRM_ACCOUNTS_REQUESTED', getWeCrmAccountsSaga)
+      );
+      expect(generator.next().done).toBe(true);
+    });
+  });
+
+  describe('getSenderDetailsSaga', () => {
+    it('should fetch sender details and put SUCCESS with parsed domains', () => {
+      const action = { payload: { channel: 'SMS', orgUnitId: 100 } };
+      const apiResponse = { entity: { SMS: [{ id: 1, domainProperties: {} }] } };
+      parseSenderDetailsResponse.mockReturnValue({ domains: [{ domainId: 1 }] });
+
+      const generator = getSenderDetailsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'SMS', 100));
+      expect(generator.next(apiResponse).value).toEqual(
+        put({ type: GET_SENDER_DETAILS_SUCCESS, payload: { channel: 'SMS', domains: [{ domainId: 1 }] } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should use orgUnitId -1 when not provided', () => {
+      const action = { payload: { channel: 'EMAIL' } };
+      const apiResponse = { entity: { EMAIL: [] } };
+      parseSenderDetailsResponse.mockReturnValue({ domains: [] });
+
+      const generator = getSenderDetailsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.getSenderDetails, 'EMAIL', -1));
+      generator.next(apiResponse);
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should return early when channel is missing', () => {
+      const action = { payload: {} };
+      const generator = getSenderDetailsSaga(action);
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should put FAILURE when response has errors', () => {
+      const action = { payload: { channel: 'SMS' } };
+      const apiResponse = { errors: [{ message: 'Forbidden' }] };
+
+      const generator = getSenderDetailsSaga(action);
+      generator.next();
+      expect(generator.next(apiResponse).value).toEqual(
+        put({
+          type: GET_SENDER_DETAILS_FAILURE,
+          payload: { channel: 'SMS', error: [{ message: 'Forbidden' }] },
+        })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should put FAILURE on throw', () => {
+      const action = { payload: { channel: 'WHATSAPP' } };
+      const generator = getSenderDetailsSaga(action);
+      generator.next();
+      const err = generator.throw(new Error('Network error'));
+      expect(err.value).toEqual(
+        put({
+          type: GET_SENDER_DETAILS_FAILURE,
+          payload: { channel: 'WHATSAPP', error: 'Network error' },
+        })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+  });
+
+  describe('getWeCrmAccountsSaga', () => {
+    it('should fetch wecrm accounts and put SUCCESS with list from response', () => {
+      const action = { payload: { sourceName: 'WHATSAPP' } };
+      const apiResult = { response: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] };
+
+      const generator = getWeCrmAccountsSaga(action);
+
+      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
+      expect(generator.next(apiResult).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'WABA1', sourceAccountIdentifier: 'waba-1' }] } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
+
+    it('should use WHATSAPP when sourceName not provided', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      expect(generator.next().value).toEqual(call(Api.fetchWeCrmAccounts, 'WHATSAPP'));
+    });
+
+    it('should use entity when response not present', () => {
+      const action = { payload: {} };
+      const apiResult = { entity: [{ name: 'Acc1' }] };
+
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      expect(generator.next(apiResult).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [{ name: 'Acc1' }] } })
+      );
+    });
+
+    it('should put empty array when result has no list', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      expect(generator.next({}).value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_SUCCESS, payload: { accounts: [] } })
+      );
+    });
+
+    it('should put FAILURE on throw', () => {
+      const action = { payload: {} };
+      const generator = getWeCrmAccountsSaga(action);
+      generator.next();
+      const err = generator.throw(new Error('API failed'));
+      expect(err.value).toEqual(
+        put({ type: GET_WECRM_ACCOUNTS_FAILURE, payload: { error: 'API failed' } })
+      );
+      expect(generator.next().done).toBe(true);
+    });
   });
 
   describe('commonTestAndPreviewSaga', () => {
@@ -1710,6 +1853,8 @@ describe('CommonTestAndPreview Sagas', () => {
           watchFetchTestGroups(),
           watchCreateMessageMeta(),
           watchGetPrefilledValues(),
+          watchGetSenderDetails(),
+          watchGetWeCrmAccounts(),
         ])
       );
 

package/v2Components/CommonTestAndPreview/tests/selectors.test.js

@@ -32,6 +32,12 @@ import {
   makeSelectUpdatePreviewErrors,
   makeSelectFetchPrefilledValuesError,
   makeSelectFetchPrefilledValuesErrors,
+  makeSelectSenderDetailsForChannel,
+  makeSelectSenderDetailsByChannel,
+  makeSelectWeCrmAccounts,
+  makeSelectIsLoadingSenderDetails,
+  makeSelectFetchSenderDetailsError,
+  makeSelectFetchWeCrmAccountsError,
 } from '../selectors';
 
 describe('CommonTestAndPreview Selectors', () => {
@@ -101,6 +107,19 @@ describe('CommonTestAndPreview Selectors', () => {
       fetchPrefilledValuesErrors: [
         { code: 7078, message: 'User profile not found' },
       ],
+      senderDetailsByChannel: {
+        SMS: [
+          { domainId: 1, domainName: 'SMS Domain', gsmSenders: [{ value: 'sender1' }] },
+        ],
+        EMAIL: [],
+        WHATSAPP: [],
+      },
+      wecrmAccounts: [
+        { name: 'WeCRM Account 1', sourceAccountIdentifier: 'waba-1' },
+      ],
+      isLoadingSenderDetails: false,
+      fetchSenderDetailsError: null,
+      fetchWeCrmAccountsError: null,
     },
   });
 
@@ -550,6 +569,133 @@ describe('CommonTestAndPreview Selectors', () => {
     });
   });
 
+  describe('makeSelectSenderDetailsForChannel', () => {
+    it('should select sender details for given channel as JS array', () => {
+      const selector = makeSelectSenderDetailsForChannel('SMS');
+      const result = selector(mockState);
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(1);
+      expect(result[0].domainName).toBe('SMS Domain');
+    });
+
+    it('should return empty array for channel with no data', () => {
+      const selector = makeSelectSenderDetailsForChannel('EMAIL');
+      const result = selector(mockState);
+
+      expect(result).toEqual([]);
+    });
+
+    it('should return empty array when substate or byChannel missing', () => {
+      const emptyState = fromJS({});
+      const selector = makeSelectSenderDetailsForChannel('SMS');
+      const result = selector(emptyState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('makeSelectSenderDetailsByChannel', () => {
+    it('should select senderDetailsByChannel and convert to JS object', () => {
+      const selector = makeSelectSenderDetailsByChannel();
+      const result = selector(mockState);
+
+      expect(result).toBeDefined();
+      expect(result.SMS).toBeDefined();
+      expect(Array.isArray(result.SMS)).toBe(true);
+      expect(result.SMS[0].domainName).toBe('SMS Domain');
+      expect(result.EMAIL).toEqual([]);
+      expect(result.WHATSAPP).toEqual([]);
+    });
+
+    it('should return empty object when domain is missing', () => {
+      const emptyState = fromJS({});
+      const selector = makeSelectSenderDetailsByChannel();
+      const result = selector(emptyState);
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('makeSelectWeCrmAccounts', () => {
+    it('should select wecrmAccounts and convert to JS array', () => {
+      const selector = makeSelectWeCrmAccounts();
+      const result = selector(mockState);
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBe(1);
+      expect(result[0].name).toBe('WeCRM Account 1');
+      expect(result[0].sourceAccountIdentifier).toBe('waba-1');
+    });
+
+    it('should return empty array when wecrmAccounts is missing', () => {
+      const emptyState = fromJS({ commonTestAndPreview: {} });
+      const selector = makeSelectWeCrmAccounts();
+      const result = selector(emptyState);
+
+      expect(result).toEqual([]);
+    });
+  });
+
+  describe('makeSelectIsLoadingSenderDetails', () => {
+    it('should select isLoadingSenderDetails flag', () => {
+      const selector = makeSelectIsLoadingSenderDetails();
+      const result = selector(mockState);
+
+      expect(result).toBe(false);
+    });
+
+    it('should return true when loading', () => {
+      const loadingState = fromJS({
+        commonTestAndPreview: { isLoadingSenderDetails: true },
+      });
+      const selector = makeSelectIsLoadingSenderDetails();
+      const result = selector(loadingState);
+
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('makeSelectFetchSenderDetailsError', () => {
+    it('should select fetchSenderDetailsError from state', () => {
+      const selector = makeSelectFetchSenderDetailsError();
+      const result = selector(mockState);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return error when present', () => {
+      const errorState = fromJS({
+        commonTestAndPreview: { fetchSenderDetailsError: 'Sender fetch failed' },
+      });
+      const selector = makeSelectFetchSenderDetailsError();
+      const result = selector(errorState);
+
+      expect(result).toBe('Sender fetch failed');
+    });
+  });
+
+  describe('makeSelectFetchWeCrmAccountsError', () => {
+    it('should select fetchWeCrmAccountsError from state', () => {
+      const selector = makeSelectFetchWeCrmAccountsError();
+      const result = selector(mockState);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return error when present', () => {
+      const errorState = fromJS({
+        commonTestAndPreview: { fetchWeCrmAccountsError: 'WeCRM fetch failed' },
+      });
+      const selector = makeSelectFetchWeCrmAccountsError();
+      const result = selector(errorState);
+
+      expect(result).toBe('WeCRM fetch failed');
+    });
+  });
+
   describe('Edge Cases', () => {
     it('should handle undefined state gracefully', () => {
       const selector = makeSelectCustomers();

package/v2Components/TestAndPreviewSlidebox/index.js

@@ -40,6 +40,9 @@ import {
   makeSelectUpdatePreviewErrors,
   makeSelectFetchPrefilledValuesError,
   makeSelectFetchPrefilledValuesErrors,
+  makeSelectSenderDetailsByChannel,
+  makeSelectWeCrmAccounts,
+  makeSelectIsLoadingSenderDetails,
 } from '../CommonTestAndPreview/selectors';
 
 /**
@@ -91,6 +94,10 @@ TestAndPreviewSlidebox.propTypes = {
   prefilledValues: PropTypes.object,
   isSendingTestMessage: PropTypes.bool.isRequired,
   intl: PropTypes.object.isRequired,
+  senderDetailsByChannel: PropTypes.object,
+  wecrmAccounts: PropTypes.array,
+  isLoadingSenderDetails: PropTypes.bool,
+  orgUnitId: PropTypes.number,
 };
 
 TestAndPreviewSlidebox.defaultProps = {
@@ -102,6 +109,10 @@ TestAndPreviewSlidebox.defaultProps = {
   currentTab: 1,
   messageMetaConfigId: null,
   prefilledValues: {},
+  senderDetailsByChannel: {},
+  wecrmAccounts: [],
+  isLoadingSenderDetails: false,
+  orgUnitId: -1,
 };
 
 const mapStateToProps = createStructuredSelector({
@@ -122,6 +133,9 @@ const mapStateToProps = createStructuredSelector({
   fetchPrefilledValuesError: makeSelectFetchPrefilledValuesError(),
   fetchPrefilledValuesErrors: makeSelectFetchPrefilledValuesErrors(),
   isSendingTestMessage: makeSelectIsSendingTestMessage(),
+  senderDetailsByChannel: makeSelectSenderDetailsByChannel(),
+  wecrmAccounts: makeSelectWeCrmAccounts(),
+  isLoadingSenderDetails: makeSelectIsLoadingSenderDetails(),
 });
 
 function mapDispatchToProps(dispatch) {

package/v2Containers/CreativesContainer/index.js

@@ -1965,14 +1965,6 @@ export class Creatives extends React.Component {
       const channelsToRemove = allChannels.filter((channel) => !allowedChannels.includes(channel));
       updatedChannelsToHide = [...new Set([...updatedChannelsToHide, ...channelsToRemove])];
     }
-    // In library mode (journey module), hide mobilepush and wechat channels from engagement blocks
-    // unless the current engagement block itself is that channel (e.g. mobilepush block should show mobilepush tab)
-    const isJourneyModule = (this.props.messageDetails?.type || '').toLowerCase() === constants.JOURNEY;
-    if (!isFullMode && isJourneyModule) {
-      const currentChannelNorm = (currentChannel || '').toLowerCase();
-      const journeyChannelsToHide = ['mobilepush', 'wechat'].filter((ch) => ch !== currentChannelNorm);
-      updatedChannelsToHide = [...new Set([...updatedChannelsToHide, ...journeyChannelsToHide])];
-    }
 
     return (
       <SlideBoxWrapper