@capillarytech/creatives-library 8.0.68-alpha.3 → 8.0.68

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.68-alpha.3",
+  "version": "8.0.68",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/v2Containers/Cap/mockData.js

@@ -1,90 +1,92 @@
 export const expectedStateGetLiquidTagsRequest = {
-    fetchingLiquidTags: true,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetLiquidTagsFailure = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetLiquidTagsSuccess = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetSchemaForEntitySuccessTAG = {
-    fetchingLiquidTags: false,
-    fetchingSchema: false,
-    fetchingSchemaError: false,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: undefined,
-      tagLookupMap: { undefined: {definition: {}} },
-      tags: { standard: { random: "32" } }
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetSchemaForEntitySuccess = {
-    fetchingLiquidTags: false,
-    fetchingSchema: false,
-    fetchingSchemaError: false,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: undefined,
-      tagLookupMap: undefined,
-      tags: undefined
-    },
-    orgID: "",
-    token: ""
-  };
+  fetchingLiquidTags: true,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetLiquidTagsFailure = {
+  fetchingLiquidTags: false,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetLiquidTagsSuccess = {
+  fetchingLiquidTags: false,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetSchemaForEntitySuccessTAG = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: false,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: undefined,
+    tagLookupMap: { undefined: { definition: {} } },
+    tags: { standard: { random: "32" } },
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetSchemaForEntitySuccess = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: false,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: undefined,
+    tagLookupMap: undefined,
+    tags: undefined,
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedForwardedTags = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: '',
+  injectedTags: undefined,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {
 
-  export const expectedForwardedTags = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: '',
-    injectedTags: undefined,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
     },
-    orgID: "",
-    token: ""
-  };
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};

package/v2Containers/Cap/reducer.js

@@ -1,7 +1,7 @@
 /**
  * Created by vivek on 22/5/17.
  */
-import { fromJS } from 'immutable';
+import { fromJS, Map as ImmutableMap } from 'immutable';
 import _ from 'lodash';
 import * as types from './constants';
 import initialState from '../../initialState';
@@ -113,20 +113,28 @@ function capReducer(state = fromJS(initialState.cap), action) {
       // Process extended tags
       const extendedSubtags = getTagMapValue(action?.data?.metaEntities?.extended);
 
+      const getExistingTagLookupMap = (state) => {
+        if (!state || !state.get) return {};
+        const tagLookupMap = state.getIn(['metaEntities', 'tagLookupMap']);
+        return state.get('metaEntities') && ImmutableMap.isMap(tagLookupMap)
+          ? tagLookupMap.toJS()
+          : {};
+      };
+
       // Combine all maps
       const combinedTagMap = {
         ...standardTagMap,
         ...customSubtags,
         ...extendedSubtags,
-        ...state.getIn(['metaEntities', 'tagLookupMap'])?.toJS(),
+        ...getExistingTagLookupMap(state),
       };
       const stateMeta = state.get("metaEntities");
       return state
         .set('fetchingSchema', false)
         .set('fetchingLiquidTags', false)
         .set('metaEntities', {
-          layouts: action.data && action.entityType === 'LAYOUT' ? action.data.metaEntities : stateMeta.layouts,
-          tags: action.data && action.entityType === 'TAG' ? action.data.metaEntities : stateMeta.tags,
+          layouts: action.data && action.entityType === 'LAYOUT' ? action.data.metaEntities : stateMeta?.layouts,
+          tags: action.data && action.entityType === 'TAG' ? action.data.metaEntities : stateMeta?.tags,
           tagLookupMap: action?.data && action?.entityType === TAG ? combinedTagMap : stateMeta?.tagLookupMap,
         })
         .set('fetchingSchemaError', false);

package/v2Containers/Cap/tests/reducer.test.js

@@ -1,16 +1,16 @@
-import { fromJS } from 'immutable';
+import { fromJS, Map as ImmutableMap } from 'immutable';
 import {
-    GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
-    GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
-    GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
-    REQUEST,
-    SUCCESS,
-    FAILURE,
-    GET_LIQUID_TAGS_SUCCESS,
-    GET_LIQUID_TAGS_FAILURE,
-    GET_LIQUID_TAGS_REQUEST,
-    GET_SCHEMA_FOR_ENTITY_SUCCESS,
-    SET_INJECTED_TAGS,
+  GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
+  GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
+  GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+  REQUEST,
+  SUCCESS,
+  FAILURE,
+  GET_LIQUID_TAGS_SUCCESS,
+  GET_LIQUID_TAGS_FAILURE,
+  GET_LIQUID_TAGS_REQUEST,
+  GET_SCHEMA_FOR_ENTITY_SUCCESS,
+  SET_INJECTED_TAGS,
 } from '../constants';
 import reducer from '../reducer';
 import initialState from '../../../initialState';
@@ -20,12 +20,13 @@ import {
   expectedStateGetLiquidTagsSuccess,
   expectedStateGetSchemaForEntitySuccessTAG,
   expectedStateGetSchemaForEntitySuccess,
-  expectedForwardedTags
 } from '../mockData';
+import { TAG } from '../../Whatsapp/constants';
+import { loadItem } from '../../../services/localStorageApi';
 
-const mockedInitialState = fromJS(initialState.cap);
 
 describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
+  const mockedInitialState = fromJS(initialState.cap);
   it('should handle GET_SUPPORT_VIDEOS_CONFIG_REQUEST', () => {
     const action = {
       type: GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
@@ -42,7 +43,7 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
       is_active: true,
       _id: "12345",
       json_config: [
-              { data: 'Test data' },
+        { data: 'Test data' },
       ],
     };
     const action = {
@@ -93,8 +94,8 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
   it('handles the GET_SCHEMA_FOR_ENTITY_SUCCESS action with action type as TAG', () => {
     const action = {
       type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
-      data: {metaEntities:{standard:{"random": "32"}}},
-      entityType: "TAG"
+      data: { metaEntities: { standard: { random: "32" } } },
+      entityType: "TAG",
     };
 
     expect(reducer(mockedInitialState, action).toJS()).toEqual(expectedStateGetSchemaForEntitySuccessTAG);
@@ -103,7 +104,7 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
   it('handles the GET_SCHEMA_FOR_ENTITY_SUCCESS action', () => {
     const action = {
       type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
-      data: {metaEntities:{standard:{"random": "32"}}},
+      data: { metaEntities: { standard: { random: "32" } } },
     };
 
     expect(reducer(mockedInitialState, action).toJS()).toEqual(expectedStateGetSchemaForEntitySuccess);
@@ -113,7 +114,108 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
       type: SET_INJECTED_TAGS,
       data: {},
     };
-    
+
     expect(reducer(mockedInitialState, action).toJS())?.fetchingSchema?.toEqual(true);
   });
 });
+
+describe('GET_SCHEMA_FOR_ENTITY_SUCCESS handler', () => {
+  it('should handle existing tagLookupMap correctly when metaEntities and tagLookupMap exist', () => {
+    const initialStateTest = fromJS({
+      token: loadItem('token') || '',
+      orgID: loadItem('orgID') || '',
+      messages: [],
+      metaEntities: {
+        tags: [{ id: 1, name: 'tag1' }],
+        layouts: ['layout1', 'layout2'],
+        tagLookupMap: {
+          existingTag: { definition: { value: 'existing' } },
+          anotherTag: { definition: { value: 'another' } },
+        },
+        standard: [],
+      },
+      liquidTags: [],
+      fetchingLiquidTags: false,
+      fetchingSchema: false,
+      fetchingSchemaError: '',
+    });
+
+    let action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: TAG,
+      data: {
+        metaEntities: {
+          standard: [],
+          custom: [],
+          extended: [],
+        },
+      },
+    };
+
+    let newState = reducer(initialStateTest, action);
+    let metaEntities = newState.get('metaEntities');
+
+    expect(metaEntities).toEqual(expect.objectContaining({
+      tagLookupMap: expect.objectContaining({
+        existingTag: expect.objectContaining({
+          definition: expect.objectContaining({
+            value: 'existing',
+          }),
+        }),
+      }),
+    }));
+
+    action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: 'LAYOUT',
+      data: {
+        metaEntities: {
+          layouts: ['layout1', 'layout2'],
+          standard: [],
+        },
+      },
+    };
+    newState = reducer(initialStateTest, action);
+    metaEntities = newState.get('metaEntities');
+    expect(metaEntities).toEqual(expect.objectContaining({
+      layouts: expect.objectContaining({
+        layouts: expect.arrayContaining(['layout1', 'layout2']),
+      }),
+    }));
+  });
+
+  it('should handle non-existent tagLookupMap by returning empty object', () => {
+    const initialStateTest = fromJS({
+      token: loadItem('token') || '',
+      orgID: loadItem('orgID') || '',
+      messages: [],
+      metaEntities: {
+        tagLookupMap: {},
+      },
+      liquidTags: [],
+      fetchingLiquidTags: false,
+      fetchingSchema: false,
+      fetchingSchemaError: '',
+    });
+
+    const action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: TAG,
+      data: {
+        metaEntities: {
+          standard: [],
+          custom: [],
+          extended: [],
+        },
+      },
+    };
+
+    const newState = reducer(initialStateTest, action);
+    const metaEntities = newState.get('metaEntities');
+
+    // Updated assertions to handle plain object
+    expect(metaEntities).toBeDefined();
+    expect(metaEntities.tagLookupMap).toBeDefined();
+    expect(metaEntities.tagLookupMap).toEqual({});
+  });
+});

package/v2Containers/CreativesContainer/index.js

@@ -1,6 +1,5 @@
 import React from 'react';
 import PropTypes from 'prop-types';
-import Bugsnag from "@bugsnag/js";
 import {
   CapSlideBox,
   CapHeader,
@@ -140,13 +139,21 @@ export class Creatives extends React.Component {
       templateData.updatedByName = commonUtil.getUserNameById(userId, usersList);
       this.setState({ slidBoxContent: constants.PREVIEW, templateData });
     } else {
-      if (template?.versions?.base?.content?.zalo?.previewUrl) {
-        commonUtil.handlePreviewInNewTab(
-          template.versions.base.content.zalo.previewUrl
-        );
-      } else {
-        Bugsnag.leaveBreadcrumb("Zalo preview url not found");
-      }
+      const {
+        name = "",
+        sourceAccountIdentifier = "",
+        configs: { token = "" } = {},
+      } = get(this.props, "Templates.selectedZaloAccount", {});
+      const { hostName = '' } = get(this.props, "Templates.senderDetails", {});
+      this.props.zaloActions.getTemplateInfoById({
+        username: name,
+        oa_id: sourceAccountIdentifier,
+        token,
+        host: hostName,
+        id: template?._id,
+        preview: true,
+        actionCallback: this.actionCallback,
+      });
     }
   };
 

package/v2Containers/Templates/index.js

@@ -12,7 +12,6 @@ import styled from 'styled-components';
 import {injectIntl, intlShape, FormattedMessage } from 'react-intl';
 import { createStructuredSelector } from 'reselect';
 import moment from "moment";
-import Bugsnag from "@bugsnag/js";
 import get from 'lodash/get';
 import isEmpty from 'lodash/isEmpty';
 import isEqual from 'lodash/isEqual';
@@ -534,8 +533,8 @@ export class Templates extends React.Component { // eslint-disable-line react/pr
         params.accountId = Number(query.account_id);
         this.getAllTemplates({params});
       }
-    }
-
+    }  
+  
 
     if (selectedChannel === "ebill" && nextProps.CreateEbill && nextProps.CreateEbill.createResponse && nextProps.CreateEbill.createResponse.templateId && nextProps.CreateEbill.createResponse.templateId !== '') {
       const message = `${this.state.channel} ${this.props.intl.formatMessage(messages.templateDuplicateSuccess)}`;
@@ -921,7 +920,7 @@ export class Templates extends React.Component { // eslint-disable-line react/pr
       }
       if (
         this.state.channel.toLowerCase() === ZALO_LOWERCASE &&
-        !isEmpty(this.props.Templates?.selectedZaloAccount) &&
+        !isEmpty(this.props.Templates?.selectedZaloAccount) && 
         !params?.isAccountSelection && !isEmpty(this.props.Templates?.selectedZaloAccount?.hostName)
       ) {
         const {
@@ -983,7 +982,7 @@ export class Templates extends React.Component { // eslint-disable-line react/pr
         default:
           return selectedWhatsappCategory === category;
       }
-    }
+    } 
     return true;
   }
   filterWhatsappTemplates = (templates) => {
@@ -1221,7 +1220,7 @@ export class Templates extends React.Component { // eslint-disable-line react/pr
           break;
         }
         case MOBILE_PUSH:
-        case INAPP:
+        case INAPP: 
           templateData.content = template;
           break;
         case WECHAT:
@@ -2190,13 +2189,21 @@ export class Templates extends React.Component { // eslint-disable-line react/pr
         this.setState({ previewTemplate: templateInfo });
       }
     } else {
-      if (template?.versions?.base?.content?.zalo?.previewUrl) {
-        handlePreviewInNewTab(
-          template.versions.base.content.zalo.previewUrl
-        );
-      } else {
-        Bugsnag.leaveBreadcrumb("Zalo preview url not found");
-      }
+      const {
+        name = "",
+        sourceAccountIdentifier = "",
+        configs: { token = "" } = {},
+        hostName = "",
+      } = get(this.props, "Templates.selectedZaloAccount", {});
+      this.props.zaloActions.getTemplateInfoById({
+        username: name,
+        oa_id: sourceAccountIdentifier,
+        token: token,
+        host: hostName || this.state.hostName || this.props.Templates?.senderDetails?.hostName,
+        id: template?._id,
+        preview: true,
+        actionCallback: this.actionCallback,
+      });
     }
   }