@capillarytech/creatives-library 7.18.0-beta.0 → 8.0.0

package/utils/authWrapper.js

@@ -1,38 +1,64 @@
 /**
  * Created by vivek on 24/5/17.
  */
-import { routerActions } from 'react-router-redux';
-import { UserAuthWrapper } from 'redux-auth-wrapper';
+
+import { connectedRouterRedirect } from 'redux-auth-wrapper/history4/redirect';
+import connectedAuthWrapper from 'redux-auth-wrapper/connectedAuthWrapper';
+import { routerActions } from 'connected-react-router';
+// import { routerActions } from 'react-router-redux';
+// import { UserAuthWrapper } from 'redux-auth-wrapper';
+import { createSelector } from 'reselect';
 import { makeSelectAuthenticated } from '../containers/Cap/selectors';
+// import config from '../config/app';
 const orginUrl = window.location.origin;
+// const loginUrl = '/auth/login';
 
-const getIsLoggedIn = () => {
+export const getIsLoggedIn = () => {
   let isLoggedIn = false;
-  if (process.env.NODE_ENV === "production" && JSON.parse(window.localStorage.getItem('isLoggedIn'))) {
+  if (
+    process.env.NODE_ENV === 'production' &&
+    JSON.parse(window.localStorage.getItem('isLoggedIn'))
+  ) {
     isLoggedIn = true;
-    
-  } else if (localStorage.getItem("token")) {
+  } else if (localStorage.getItem('token')) {
     isLoggedIn = true;
-    
   }
   return isLoggedIn;
 };
 
+const makeSelectAuthenticatedWithPredicate = state =>
+  createSelector(
+    makeSelectAuthenticated(state),
+    global => global && global.isLoggedIn,
+  );
 
-// Take the regular authentication & redirect to login from before
-export const UserIsAuthenticated = UserAuthWrapper({
-  authSelector: makeSelectAuthenticated(),
-  redirectAction: routerActions.replace,
+export const UserIsAuthenticated = connectedAuthWrapper({
+  authenticatedSelector: makeSelectAuthenticatedWithPredicate(),
   predicate: () => getIsLoggedIn(),
   wrapperDisplayName: 'UserIsAuthenticated',
   failureRedirectPath: `${orginUrl}/auth/login`,
+  redirectAction: routerActions.replace,
 });
 
-export const UserIsNotAuthenticated = UserAuthWrapper({
-  authSelector: makeSelectAuthenticated(),
-  redirectAction: routerActions.replace,
-  wrapperDisplayName: 'UserIsNotAuthenticated',
+const makeSelectNotAuthenticatedWithPredicate = state =>
+  createSelector(
+    makeSelectAuthenticated(state),
+    global => !(global && global.isLoggedIn),
+  );
+
+export const UserIsNotAuthenticated = connectedRouterRedirect({
+  authenticatedSelector: makeSelectNotAuthenticatedWithPredicate(),
   predicate: () => !getIsLoggedIn(),
-  failureRedirectPath: (state, ownProps) => ownProps.location.query.redirect ? ownProps.location.query.redirect : '/campaign',
+  wrapperDisplayName: 'UserIsNotAuthenticated',
+  redirectAction: routerActions.replace,
+  redirectPath: (state, ownProps) => {
+    // console.log('ownProps', ownProps);
+    const urlParams = new URLSearchParams(ownProps.location.search);
+    const redirectUrl = urlParams.get('redirect')
+      ? urlParams.get('redirect')
+      : '/';
+    return redirectUrl;
+  },
+  // redirectPath: loginUrl,
   allowRedirectBack: false,
-});
+});

package/utils/cdnTransformation.js

@@ -28,6 +28,7 @@ const CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX_KEY = 'CREATIVES_CDN_TRANSFORMATIO
 const CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_KEY = 'CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY';
 const CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_MAPPING_KEY = 'CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_MAPPING';
 export const CREATIVES_S3_ASSET_FILESIZES = 'CREATIVES_S3_ASSET_FILESIZES';
+export const S3_CDN_MAP_KEY = 'S3_CDN_MAP';
 
 const HTTPS_STR = "https://"
 const ALLOWED_EXTENSIONS_STR = ".*(?:jpg|png|jpeg|gif)$"
@@ -110,6 +111,31 @@ const CHANNEL_CONFIGS = {
   }
 };
 
+/**
+ * Retrieves the cluster-specific S3 CDN configuration from the given URL based on S3_CDN_MAP.
+ *
+ * @param {string} url - The URL to check for cluster-specific S3 CDN configuration.
+ * @returns {Object} - An object containing the cluster-specific S3 bucket path and CDN base URL.
+ */
+const getClusterSpecificS3CdnConfigFromUrl = (url) => {
+  const S3_CDN_MAP = getLocalStorageItem(S3_CDN_MAP_KEY, true);
+  let CREATIVES_S3_BUCKET_PATH;
+  let CREATIVES_CDN_BASE_URL;
+
+  Object.entries(S3_CDN_MAP).some(([clusterS3Url, cdnConfigs]) => {
+    const {cdn_host, bucket_path} = cdnConfigs;
+    const s3UrlRegex = new RegExp(`^https://${clusterS3Url}/${bucket_path}/\.*`);
+    const cdnUrlRegex = new RegExp(`^https://${cdn_host}/\.*${bucket_path}/\.*`);
+
+    if (s3UrlRegex.test(url) || cdnUrlRegex.test(url)) {
+      CREATIVES_S3_BUCKET_PATH = bucket_path;
+      CREATIVES_CDN_BASE_URL = `https://${cdn_host}`;
+      return true;
+    }
+  });
+  return { CREATIVES_S3_BUCKET_PATH, CREATIVES_CDN_BASE_URL };
+}
+
 /**
  * 
  * @param {string} url : required 
@@ -144,88 +170,86 @@ export const getCdnUrl = ({
   emailOverrideQuality = null,
 }) => {
   try{
+    let cdnUrl;
     const channelName = receivedChannelName?.toUpperCase();
     const channelSubType = receivedChannelSubType?.toUpperCase();
-  
-    const CREATIVES_CDN_BASE_URL = getLocalStorageItem(CREATIVES_CDN_BASE_URL_KEY);
+
     const CREATIVES_CDN_QUALITY_CONFIG = getLocalStorageItem(CREATIVES_CDN_QUALITY_CONFIG_KEY, true);
     const CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX = getLocalStorageItem(CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX_KEY);
-    let CREATIVES_S3_BUCKET_PATH = getLocalStorageItem(CREATIVES_S3_BUCKET_PATH_KEY);
-    
-    //remove all leading and trailing forward slash with empty string, if leading/trailing forward slash is present in node env by mistake then url will not be correct hence removing them.
-    CREATIVES_S3_BUCKET_PATH = CREATIVES_S3_BUCKET_PATH?.replace(/^\/|\/$/g, '');
+
+    //Get cluster specific S3 CDN configuration from the given URL based on S3_CDN_MAP
+    let { CREATIVES_S3_BUCKET_PATH, CREATIVES_CDN_BASE_URL } = getClusterSpecificS3CdnConfigFromUrl(url);
 
     //Basic validations on data stored in local storage.
     if (
       typeof CREATIVES_CDN_QUALITY_CONFIG !== "object" ||
       Array.isArray(CREATIVES_CDN_QUALITY_CONFIG) ||
       CREATIVES_CDN_QUALITY_CONFIG === null ||
-      typeof CREATIVES_CDN_BASE_URL !== "string" || 
-      typeof CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX !== "string" || 
-      typeof CREATIVES_S3_BUCKET_PATH !== 'string'
+      !CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX ||
+      !CREATIVES_S3_BUCKET_PATH ||
+      !CREATIVES_CDN_BASE_URL
     )
       return url;
-  
+
+    //remove all leading and trailing forward slash with empty string, if leading/trailing forward slash is present in node env by mistake then url will not be correct hence removing them.
+    CREATIVES_S3_BUCKET_PATH = CREATIVES_S3_BUCKET_PATH?.replace(/^\/|\/$/g, '');
+
     const QUALITY = CREATIVES_CDN_QUALITY_CONFIG?.[channelName] || CREATIVES_CDN_QUALITY_CONFIG?.DEFAULT;
+    const [_, assetKey] = url.split(CREATIVES_S3_BUCKET_PATH);
   
     const regexWithExtension = new RegExp(HTTPS_STR + ANY_STR + CREATIVES_S3_BUCKET_PATH + ANY_STR + ALLOWED_EXTENSIONS_STR)
     const regexWithoutExtension = new RegExp(HTTPS_STR + ANY_STR + CREATIVES_S3_BUCKET_PATH + ANY_STR);
-
-    let skipTransformations = true;
-
+    
     if (
       !regexWithoutExtension.test(url) ||
       !CHANNEL_CONFIGS?.[channelName] ||
       (channelSubType && !CHANNEL_CONFIGS?.[channelName]?.[channelSubType]) ||
-      !CREATIVES_CDN_BASE_URL ||
-      !CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX ||
-      !QUALITY
+      !QUALITY ||
+      !assetKey
     )
       return url;
+    
+    let skipTransformations = true;
+    let applicableTransformations;
 
     //Skip transformations if extensions are not proper. Else consider transformations if available.
     if(regexWithExtension.test(url)){
       skipTransformations = false;
     }
-
-    const [, assetKey] = url.split(CREATIVES_S3_BUCKET_PATH);
-  
-    let newUrl = `${CREATIVES_CDN_BASE_URL}`;
-  
-    let applicableTransformations;
   
+    //Skip trasformations if transformation properties are not present in channel/subchannel.
     if (channelSubType) {
       applicableTransformations =
         CHANNEL_CONFIGS?.[channelName]?.[channelSubType]?.transformations;
     } else {
       applicableTransformations = CHANNEL_CONFIGS?.[channelName]?.transformations;
     }
+
+    cdnUrl = `${CREATIVES_CDN_BASE_URL}`;    
   
     if (!isEmpty(applicableTransformations) && !skipTransformations) {
+      cdnUrl += `/${CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX}/`;
   
-      newUrl += `/${CREATIVES_CDN_TRANSFORMATION_URL_SUFFIX}/`;
-  
-      // Object.keys(applicableTransformations)?.forEach((transformationParam) => {
       forOwn(applicableTransformations, (transformationParamVal, transformationParam)=>{
         try {
           switch (transformationParam) {
             case "height":
               if (transformationParamVal === SPECIFIED && height) {
-                newUrl += `${transformationParam}=${height},`;
+                cdnUrl += `${transformationParam}=${height},`;
               } else if(transformationParamVal !== SPECIFIED && isNumber(transformationParamVal)) {
-                newUrl += `${transformationParam}=${transformationParamVal},`;
+                cdnUrl += `${transformationParam}=${transformationParamVal},`;
               }
               break;
             case "width":
               if (transformationParamVal === SPECIFIED && width) {
-                newUrl += `${transformationParam}=${width},`;
+                cdnUrl += `${transformationParam}=${width},`;
               } else if(transformationParamVal !== SPECIFIED && isNumber(transformationParamVal)) {
-                newUrl += `${transformationParam}=${transformationParamVal},`;
+                cdnUrl += `${transformationParam}=${transformationParamVal},`;
               }
               break;
             case "format":
               if(transformationParamVal){
-                newUrl += `${transformationParam}=${transformationParamVal},`;
+                cdnUrl += `${transformationParam}=${transformationParamVal},`;
               }
               break;
             case "quality":
@@ -234,12 +258,12 @@ export const getCdnUrl = ({
                   emailOverrideQuality &&
                   typeof emailOverrideQuality === "number"
                 ) {
-                  newUrl += `${transformationParam}=${emailOverrideQuality},`;
+                  cdnUrl += `${transformationParam}=${emailOverrideQuality},`;
                 } else {
-                  newUrl += `${transformationParam}=${QUALITY},`;
+                  cdnUrl += `${transformationParam}=${QUALITY},`;
                 }
               } else {
-                newUrl += `${transformationParam}=100,`;
+                cdnUrl += `${transformationParam}=100,`;
               }
               break;
           }
@@ -251,9 +275,8 @@ export const getCdnUrl = ({
         }
       })
     }
-    newUrl += `/${CREATIVES_S3_BUCKET_PATH}${assetKey}`;
-    return newUrl;
-
+    cdnUrl += `/${CREATIVES_S3_BUCKET_PATH}${assetKey}`;
+    return cdnUrl;
   }catch(e){
     Bugsnag.leaveBreadcrumb("Some exception occurred in getCdnUrl");
     Bugsnag.notify(e, (event) => {
@@ -389,6 +412,7 @@ export function removeAllCdnLocalStorageItems() {
     removeLocalStorageItem(CREATIVES_S3_BUCKET_PATH_KEY);
     removeLocalStorageItem(CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_KEY);
     removeLocalStorageItem(CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_MAPPING_KEY);
+    removeLocalStorageItem(S3_CDN_MAP_KEY);
   }catch(e){
     Bugsnag.leaveBreadcrumb("some error occured while deleting all keys for cdn");
     Bugsnag.notify(e, (event) => {
@@ -476,6 +500,13 @@ export function saveCdnConfigs(configsResponse) {
         CREATIVES_CDN_OVERRIDE_DEFAULT_EMAIL_QUALITY_MAPPING_KEY
       );
     }
+
+    if (configsResponse?.s3CdnMap) {
+      const strigifiedS3CdnMap = JSON.stringify(configsResponse?.s3CdnMap);
+      localStorage.setItem(S3_CDN_MAP_KEY, strigifiedS3CdnMap);
+    } else {
+      removeLocalStorageItem(S3_CDN_MAP_KEY);
+    }
   } catch (e) {
     Bugsnag.leaveBreadcrumb("some error while setting localstorage cdn configs");
     Bugsnag.notify(e, (event) => {
@@ -509,8 +540,8 @@ export function storeS3FileSizeDetails(url, fileSize) {
 export function getKeyFromS3Url(url) {
   if (typeof url !== "string") return url;
 
-  const bucketPathWithSlash =
-    getLocalStorageItem(CREATIVES_S3_BUCKET_PATH_KEY) + "/";
+  const { CREATIVES_S3_BUCKET_PATH }  = getClusterSpecificS3CdnConfigFromUrl(url);
+  const bucketPathWithSlash = CREATIVES_S3_BUCKET_PATH + "/";
   const [, key] = url.split(bucketPathWithSlash);
   return key;
 }
@@ -527,22 +558,20 @@ export function getKeyFromS3Url(url) {
  * 'isCdnUrl' refers that it is cdn url.
  */
 export function checkValidUrl(url){
+  const { CREATIVES_S3_BUCKET_PATH, CREATIVES_CDN_BASE_URL }  = getClusterSpecificS3CdnConfigFromUrl(url);
 
-  const CREATIVES_CDN_BASE_URL = getLocalStorageItem(CREATIVES_CDN_BASE_URL_KEY);
-
-  let CREATIVES_S3_BUCKET_PATH = getLocalStorageItem(CREATIVES_S3_BUCKET_PATH_KEY);
   const regexWithExtension = new RegExp(HTTPS_STR + ANY_STR + CREATIVES_S3_BUCKET_PATH + ANY_STR + ALLOWED_EXTENSIONS_STR)
-
+  
   //It is S3 url if tests with regex but doesn't contain cdn base url.
-
+  
   const isValidUrl = regexWithExtension.test(url);
   const isCdnUrl = url.includes(CREATIVES_CDN_BASE_URL);
   const isS3Url = isValidUrl && !isCdnUrl;
 
   return {
     isValidUrl,
-    isCdnUrl,
     isS3Url,
+    isCdnUrl,
   }
 }
 

package/utils/checkStore.js

@@ -0,0 +1,21 @@
+import { conformsTo, isFunction, isObject } from 'lodash';
+import invariant from 'invariant';
+
+/**
+ * Validate the shape of redux store
+ */
+export default function checkStore(store) {
+  const shape = {
+    dispatch: isFunction,
+    subscribe: isFunction,
+    getState: isFunction,
+    replaceReducer: isFunction,
+    runSaga: isFunction,
+    injectedReducers: isObject,
+    injectedSagas: isObject,
+  };
+  invariant(
+    conformsTo(store, shape),
+    '(app/utils...) injectors: Expected a valid redux store',
+  );
+}

package/utils/common.js

@@ -1,11 +1,28 @@
 import _ from 'lodash';
+import Bugsnag from '@bugsnag/js';
 import { Auth } from '@capillarytech/cap-ui-utils';
 import {
   STORE2DOOR_PLUS_ENABLED,
   TRAI_DLT,
   CARD_RELATED_TAGS,
   CARD_BASED_SCOPE,
+  HOSPITALITY_RELATED_TAGS,
+  HOSPITALITY_BASED_SCOPE,
+  GIFT_CARDS,
+  PROMO_ENGINE,
+  EXTENDED_TAG,
+  CUSTOMER_EXTENDED_FIELD,
+  CUSTOM_TAG,
+  REGISTRATION_CUSTOM_FIELD,
+  JP_LOCALE_HIDE_FEATURE,
+  ENABLE_CUSTOMER_BARCODE_TAG,
+  BADGES_UI_ENABLED,
+  BADGES_ENROLL,
+  EMAIL_UNSUBSCRIBE_TAG_MANDATORY,
+  BADGES_ISSUE,
+  ENABLE_WECHAT,
 } from '../containers/App/constants';
+import { apiMessageFormatHandler } from './commonUtils';
 
 export function getUserNameById(userId, allUserList) {
   let userName = "";
@@ -38,6 +55,15 @@ export function removeLinksFromHtmlContent(content) {
   return copyContent;
 }
 
+export function iframePreviewAdjustWidth(content) {
+  const doc = document.createElement('html');
+  doc.innerHTML = content;
+  let copyContent = doc.cloneNode(true).outerHTML;
+  copyContent = copyContent.replace(/<img /g, '<img width="310" ');
+  doc.remove();
+  return copyContent;
+}
+
 export const hasStore2DoorFeature = Auth.hasFeatureAccess.bind(
   null,
   STORE2DOOR_PLUS_ENABLED,
@@ -53,16 +79,61 @@ export const hasCardBasedScope = Auth.hasFeatureAccess.bind(
   CARD_BASED_SCOPE,
 );
 
+export const hasHospitalityBasedScope = Auth.hasFeatureAccess.bind(
+  null,
+  HOSPITALITY_BASED_SCOPE,
+);
+export const hasPromoFeature = Auth.hasFeatureAccess.bind(
+  null,
+  PROMO_ENGINE,
+);
+
+export const hasGiftVoucherFeature = Auth.hasFeatureAccess.bind(
+  null,
+  GIFT_CARDS,
+);
+
+export const hasBadgesFeature = Auth.hasFeatureAccess.bind(
+  null,
+  BADGES_UI_ENABLED
+);
+
+export const hasJPLocaleHideFeatureEnabled = Auth.hasFeatureAccess.bind(
+  null,
+  JP_LOCALE_HIDE_FEATURE,
+);
+
+export const hasWechatFeatureEnabled = Auth.hasFeatureAccess.bind(
+  null,
+  ENABLE_WECHAT,
+);
+
+export const hasCustomerBarcodeFeatureEnabled = Auth.hasFeatureAccess.bind(
+  null,
+  ENABLE_CUSTOMER_BARCODE_TAG,
+);
+
+export const isEmailUnsubscribeTagMandatory = Auth.hasFeatureAccess.bind(
+  null,
+  EMAIL_UNSUBSCRIBE_TAG_MANDATORY,
+);
+//filtering tags based on scope
+export const filterTags = (tagsToFilter, tagsList) => tagsList?.filter(
+    (tag) => !tagsToFilter?.includes(tag?.definition?.value)
+);
+
 export function getTreeStructuredTags({tagsList, userLocale = 'en', offerDetails = [], disableTagsDetails = {}}) {
-  console.log('populating tags', (tagsList || []).length);
   const mainTags = {};
   const { disableRelatedTags, childTagsToDisable, parentTagstoDisable} = disableTagsDetails;
 
   let clonedTags = tagsList;
   if (!hasCardBasedScope()) {
-    clonedTags = _.filter(tagsList, (tag) =>
-      !CARD_RELATED_TAGS.includes(tag?.definition?.value)
-    );
+    //filtering CARD_RELATED_TAGS if org does not have CARD_BASED_SCOPE feature enabled
+    clonedTags = filterTags(CARD_RELATED_TAGS, tagsList);
+  }
+  if (!hasHospitalityBasedScope()) {
+    //filtering HOSPITALITY_RELATED_TAGS if org does not have HOSPITALITY_BASED_SCOPE feature enabled
+    clonedTags = filterTags(HOSPITALITY_RELATED_TAGS, tagsList);
   }
   _.forEach(clonedTags, (temp) => {
     const tag = temp.definition;
@@ -118,8 +189,12 @@ export function getTreeStructuredTags({tagsList, userLocale = 'en', offerDetails
     }
   });
   let combinedTags = result;
-  if (offerDetails.length) {
-    combinedTags = transformCouponTags(offerDetails, result);
+  if (offerDetails?.length) {
+    if ([BADGES_ENROLL, BADGES_ISSUE].includes(offerDetails?.[0]?.type)) {
+      combinedTags = transformBadgeTags(offerDetails, result);
+    } else {
+      combinedTags = transformCouponTags(offerDetails, result);
+    }
   }
   return getTreeStructureData(combinedTags);
 }
@@ -145,7 +220,7 @@ function transformCouponTags(offerDetails, allTags) {
     return {
       ...obj,
       ...tempObj,
-      couponSeriesId: id,
+      incentiveSeriesId: id,
     };
   };
   offerDetails.forEach((offer) => {
@@ -168,7 +243,7 @@ function transformCouponTags(offerDetails, allTags) {
       'tag-header': true,
       'name': couponNameFinal || couponId,
       'desc': couponNameFinal || couponId,
-      'couponSeriesId': couponId,
+      'incentiveSeriesId': couponId,
       'subtags': couponSubTags,
       'resolved': true,
       'couponTags': true,
@@ -179,6 +254,44 @@ function transformCouponTags(offerDetails, allTags) {
   return allTags;
 }
 
+export function transformBadgeTags(badgeDetails = [], allTags) {
+  const badgeTags = {};
+  const badgeTagsKeys = Object.keys(_.get(allTags, 'Badge.subtags', []));
+  const withBadgeId = (obj, id) => {
+    const tempObj = {};
+    if (obj?.subtags) {
+      tempObj.subtags = _.mapValues(obj.subtags, (tag) => ({
+        ...withBadgeId(tag, id),
+      }));
+    }
+    return {
+      ...obj,
+      ...tempObj,
+      incentiveSeriesId: id,
+    };
+  };
+  badgeDetails.forEach((offer) => {
+    const { badgesMetaId, badgeName } = offer || {};
+    const badgeSubTags = {};
+    badgeTagsKeys.forEach((badgeTagKey) => {
+      const badgeSubTagsObj = withBadgeId(allTags?.Badge?.subtags?.[badgeTagKey], badgesMetaId);
+      badgeSubTags[badgeTagKey] = badgeSubTagsObj;
+    });
+    badgeTags[badgesMetaId] = {
+      'tag-header': true,
+      'name': badgeName,
+      'desc': badgeName,
+      'incentiveSeriesId': badgesMetaId,
+      'subtags': badgeSubTags,
+      'resolved': true,
+      'couponTags': true,
+    };
+  });
+  // eslint-disable-next-line no-param-reassign
+  allTags.Badge.subtags = badgeTags;
+  return allTags;
+}
+
 function populateTagForChildren(targetTag, tagsObject, tagValue) {
   const tag = targetTag;
   if (tag && tag['tag-header'] && !tag.resolved) {
@@ -262,3 +375,80 @@ export const isTraiDLTEnable = (isFullMode, smsRegister) => {
   const isTraiDltFeature = isTraiDltFeatureForOrg && isTraiEnableforLib;
   return isTraiDltFeature;
 };
+
+//Input: " Spaces In Input "---> Output: "spaces_in_input"
+export const intlKeyGenerator = (value = "") => String(value).replace(/[^a-zA-Z0-9_ ]/g, "").replace(/ /g, "_").toLowerCase();
+
+export const handleInjectedData = (data, scope) => {
+  let tagType;
+  for (const tagKey in data) {
+    if (data.hasOwnProperty(tagKey)) {
+      const tag = data[tagKey];
+      if (tag?.name === REGISTRATION_CUSTOM_FIELD) {
+        tagType = CUSTOM_TAG;
+      } else if (tag?.name === CUSTOMER_EXTENDED_FIELD) {
+        tagType = EXTENDED_TAG;
+      }
+
+      if (tag?.name) {
+        const name = tag.name;
+        const key = intlKeyGenerator(name);
+        const id = tagType
+          ? `${scope}.${key}_name.${tagType}`
+          : `${scope}.${key}`;
+
+        tag.name = apiMessageFormatHandler(id, name);
+      }
+
+      if (tag?.subtags) {
+        for (const subtagKey in tag.subtags) {
+          if (tag.subtags.hasOwnProperty(subtagKey)) {
+            const subtag = tag.subtags[subtagKey];
+            if (subtag?.name) {
+              const name = subtag?.name;
+              const key = intlKeyGenerator(name);
+              const id = tagType
+                ? `${scope}.${key}_name.${tagType}`
+                : `${scope}.${key}`;
+
+              subtag.name = apiMessageFormatHandler(id, name);
+            }
+            if (subtag?.desc) {
+              const desc = subtag?.desc;
+              const key = intlKeyGenerator(desc);
+              const id = tagType
+                ? `${scope}.${key}_desc.${tagType}`
+                : `${scope}.${key}`;
+
+              subtag.desc = apiMessageFormatHandler(id, desc);
+            }
+          }
+        }
+      }
+      tagType = "";
+    }
+  }
+  return data;
+};
+
+export const handlePreviewInNewTab = (previewUrl) => {
+  window.open(previewUrl, '_blank');
+};
+
+export const getDecodedFileName = (templateName = '') => {
+  try {
+    return decodeURIComponent(templateName);
+  } catch (error) {
+    // If decoding fails due to URIError, using the original encoded filename
+    if (error instanceof URIError) {
+      return templateName;
+    } else {
+      // For other errors, registering the exception in Bugsnag
+      Bugsnag.leaveBreadcrumb("Error decoding the string:", error);
+      Bugsnag.notify(error, (event) => {
+        event.severity = "error";
+      });
+    }
+  }
+  return templateName;
+};

package/utils/commonUtils.js

@@ -3,4 +3,20 @@ import { FormattedMessage } from 'react-intl';
 
 export const apiMessageFormatHandler = (id, fallback) => (
     <FormattedMessage id={id} defaultMessage={fallback} />
-);
+);
+
+export const addBaseToTemplate = (template) => {
+  const { versions: {
+    history = [],
+  } = {}} = template || {};
+  if (history?.length) {
+    return ({
+      ...template,
+      versions: {
+        ...template.versions,
+        base: history[0],
+      },
+    });
+  }
+  return template;
+};