@capillarytech/creatives-library 7.17.21-alpha.0 → 7.17.21-alpha.2

package/containers/App/constants.js

@@ -5,6 +5,7 @@ export const GET_SIDEBAR_FAILURE = 'app/App/GET_SIDEBAR_FAILURE';
 export const STORE2DOOR_PLUS_ENABLED = 'STORE2DOOR_PLUS_ENABLED';
 export const TRAI_DLT = 'TRAI_DLT';
 export const CARD_BASED_SCOPE = 'CARD_BASED_SCOPE';
+export const HOSPITALITY_BASED_SCOPE = 'HOSPITALITY_BASED_SCOPE';
 
 export const CARD_RELATED_TAGS = [
   'card_series',
@@ -14,3 +15,25 @@ export const CARD_RELATED_TAGS = [
   'card_series_name',
   'card_name',
 ];
+
+export const HOSPITALITY_RELATED_TAGS = [
+  "hospitality_series",
+  "tax_Code",
+  "roomTypeCode",
+  "bookingChannel",
+  "hotelReservationID_ResID_Type",
+  "lastModifyDateTime",
+  "guestCounts_IsPerRoom",
+  "ratePlan_RatePlanCode",
+  "resID_Value",
+  "numberOfUnits",
+  "rateTimeUnit",
+  "resStatus",
+  "timeSpan_End",
+  "roomStay_MarketCode",
+  "createDateTime",
+  "amount",
+  "timeSpan_Start",
+  "email",
+  "resID_Source",
+];

package/package.json

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

package/utils/common.js

@@ -5,6 +5,8 @@ import {
   TRAI_DLT,
   CARD_RELATED_TAGS,
   CARD_BASED_SCOPE,
+  HOSPITALITY_RELATED_TAGS,
+  HOSPITALITY_BASED_SCOPE,
 } from '../containers/App/constants';
 import { apiMessageFormatHandler } from './commonUtils';
 
@@ -54,16 +56,28 @@ export const hasCardBasedScope = Auth.hasFeatureAccess.bind(
   CARD_BASED_SCOPE,
 );
 
+export const hasHospitalityBasedScope = Auth.hasFeatureAccess.bind(
+  null,
+  HOSPITALITY_BASED_SCOPE,
+);
+
+//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;

package/utils/tests/common.mockdata.js

@@ -0,0 +1,125 @@
+export const tagsList = [
+  {
+    _id: "6501b8b2ddd26e9da234b7c0",
+    type: "TAG",
+    definition: {
+      "resolutionDetails": {
+        resolver: "EI",
+        reference:
+          "select check_in_date.date as timeSpan_Start from read_api_2000014.behavioural_catalog_reservation a join read_api_2000014.date check_in_date on check_in_date.date_id=a.dim_timespan_start_id join read_api_2000014.date modified_date on modified_date.date_id=a.dim_latest_updated_date_id join read_api_2000014.date lastmodifydate on lastmodifydate.date_id=a.dim_lastmodifydatetime_id join read_api_2000014.date d ON a.dim_event_date_id = d.date_id join read_api_2000014.date booking_date ON a.dim_createdatetime_id = booking_date.date_id join read_api_2000014.date check_out_date ON a.dim_timespan_end_id = check_out_date.date_id join (select resid_value,  max(date) as max_updated_date from read_api_2000014.behavioural_catalog_reservation a join read_api_2000014.date d on d.date_id=a.dim_latest_updated_date_id group by 1 ) b on a.resid_value=b.resid_value and b.max_updated_date=modified_date.date where resstatus='Reserved' and datediff(check_in_date.date, date(now()) )= 3",
+        type: "QUERY",
+      },
+      "subType": "EXTERNAL",
+      "label": {
+        "zh-cn": "",
+        "en": "Checkin date",
+      },
+      "value": "timeSpan_Start",
+      "subtags": [],
+      "tag-header": false,
+      "supportedModules": [
+        {
+          mandatory: false,
+          layout: "sms",
+          context: "default",
+        },
+        {
+          mandatory: false,
+          layout: "sms",
+          context: "outbound",
+        },
+        {
+          mandatory: false,
+          layout: "email",
+          context: "default",
+        },
+        {
+          mandatory: false,
+          layout: "email",
+          context: "outbound",
+        },
+      ],
+    },
+    scope: {
+      tag: "STANDARD",
+      orgId: -1,
+      verticals: [],
+    },
+    isActive: true,
+    createdBy: 50685535,
+    updatedBy: 50685535,
+    createdAt: "2023-09-13T13:27:14.653Z",
+    updatedAt: "2023-09-13T13:27:14.653Z",
+  },
+  {
+    _id: "5a291cdd85c3db29a2041e5a",
+    type: "TAG",
+    definition: {
+      "label": {
+        "en": "Optout",
+        "ja-JP": "撤回",
+      },
+      "value": "optout",
+      "subtags": [],
+      "tag-header": false,
+      "supportedModules": [
+        {
+          context: "journey",
+          layout: "sms",
+          mandatory: false,
+        },
+        {
+          context: "outbound",
+          layout: "sms",
+          mandatory: false,
+        },
+        {
+          context: "default",
+          layout: "sms",
+          mandatory: false,
+        },
+        {
+          context: "coupon_expiry",
+          layout: "sms",
+          mandatory: false,
+        },
+        {
+          context: "coupons",
+          layout: "sms",
+          mandatory: false,
+        },
+      ],
+    },
+    scope: {
+      tag: "STANDARD",
+      orgId: -1,
+      verticals: [],
+    },
+    isActive: true,
+    createdBy: 4,
+    updatedBy: 15000449,
+    createdAt: "2017-12-07T10:50:05.800Z",
+    updatedAt: "2018-01-22T11:43:05.611Z",
+  },
+];
+export const tagsToFilter = ["timeSpan_Start"];
+
+export const output1 = [
+  {
+    disabled: false,
+    title: "Optout",
+    value: "{{optout}}",
+  },
+];
+export const output2 = [
+  {
+    disabled: false,
+    title: "Checkin date",
+    value: "{{timeSpan_Start}}",
+  },
+  {
+    disabled: false,
+    title: "Optout",
+    value: "{{optout}}",
+  },
+];

package/utils/tests/common.test.js

@@ -0,0 +1,98 @@
+import React from 'react';
+import { FormattedMessage } from 'react-intl';
+import "@testing-library/jest-dom";
+import { filterTags, getTreeStructuredTags, handleInjectedData } from "../common";
+import * as mockdata from "./common.mockdata";
+
+describe("getTreeStructuredTags test", () => {
+  it("test for getTreeStructuredTags when tagsList is not empty", () => {
+    expect(getTreeStructuredTags({tagsList: mockdata.tagsList})).toEqual(mockdata.output1);
+  });
+  it("test for getTreeStructuredTags when tagsList is empty", () => {
+    expect(getTreeStructuredTags({tagsList: []})).toEqual([]);
+  });
+  it("test for filterTags", () => {
+    expect(filterTags(mockdata.tagsToFilter, mockdata.tagsList)).toEqual([mockdata.tagsList[1]]);
+  });
+  it("test for filterTags when tagsToFilter and tagsList is empty", () => {
+    expect(filterTags([], [])).toEqual([]);
+  });
+});
+
+describe("handleInjectedData", () => {
+  it("replaces name with intl key for top level tag", () => {
+    const data = {
+      tag1: {
+        name: "Registration Fields",
+      },
+    };
+
+    const result = handleInjectedData(data, "scope");
+
+    expect(result.tag1.name).toEqual(<FormattedMessage defaultMessage="Registration Fields" id="scope.RegistrationFields" values={{}} />);
+  });
+
+  it("adds tagType for Registration custom fields", () => {
+    const data = {
+      tag1: {
+        name: "Registration custom fields",
+      },
+    };
+
+    const result = handleInjectedData(data, "scope");
+
+    expect(result.tag1.name).toEqual(
+      <FormattedMessage defaultMessage="Registration custom fields" id="scope.Registrationcustomfields_name.CustomTagMessage" values={{}} />
+    );
+  });
+
+  it("adds tagType for Customer extended fields fields", () => {
+    const data = {
+      tag1: {
+        name: "Customer extended fields",
+      },
+    };
+
+    const result = handleInjectedData(data, "scope");
+
+    expect(result.tag1.name).toEqual(
+      <FormattedMessage defaultMessage="Customer extended fields" id="scope.Customerextendedfields_name.ExtendedTagMessage" values={{}} />
+    );
+  });
+
+
+  it("replaces subtag name with intl key", () => {
+    const data = {
+      tag1: {
+        subtags: {
+          subtag1: {
+            name: "First Name",
+          },
+        },
+      },
+    };
+
+    const result = handleInjectedData(data, "scope");
+
+    expect(result.tag1.subtags.subtag1.name).toEqual(<FormattedMessage defaultMessage="First Name" id="scope.FirstName" values={{}} />);
+  });
+
+  it("replaces subtag desc with intl key", () => {
+    const data = {
+      tag1: {
+        subtags: {
+          subtag1: {
+            desc: "Enter your first name",
+          },
+        },
+      },
+    };
+
+    const result = handleInjectedData(data, "scope");
+
+    expect(result.tag1.subtags.subtag1.desc).toEqual(
+      <FormattedMessage defaultMessage="Enter your first name" id="scope.Enteryourfirstname" values={{}} />
+    );
+  });
+});
+

package/utils/tests/commonUtil.test.js

@@ -0,0 +1,21 @@
+import "@testing-library/jest-dom";
+import { getTreeStructuredTags } from "../common";
+import * as mockdata from "./common.mockdata";
+
+jest.mock('@capillarytech/cap-ui-utils', () => ({
+  Auth: {
+    hasAccess: () => jest.fn(() => true),
+    hasFeatureAccess: () => jest.fn(() => true),
+    authHoc: jest.fn(),
+    initialize: jest.fn(),
+  },
+}));
+
+describe("common utils test", () => {
+  it("test for getTreeStructuredTags when tagsList is not empty", () => {
+    expect(getTreeStructuredTags({tagsList: mockdata.tagsList})).toEqual(mockdata.output2);
+  });
+  it("test for getTreeStructuredTags when tagsList is empty", () => {
+    expect(getTreeStructuredTags({tagsList: []})).toEqual([]);
+  });
+});

package/v2Components/CapTagList/index.js

@@ -7,6 +7,8 @@
 import PropTypes from 'prop-types';
 import React from 'react';
 import { connect } from 'react-redux';
+import moment from 'moment';
+import { FONT_COLOR_05 } from '@capillarytech/cap-ui-library/styled/variables';
 // import styled from 'styled-components';
 import { CapSpin, CapModal, CapButton, CapPopover, CapInput, CapTree, CapSelect, CapTooltip, CapLink, CapIcon } from '@capillarytech/cap-ui-library';
 
@@ -15,10 +17,9 @@ import { FormattedMessage, injectIntl, intlShape } from 'react-intl';
 import { createStructuredSelector } from 'reselect';
 import messages from './messages';
 import { makeSelectLoyaltyPromotionDisplay } from '../../v2Containers/Cap/selectors';
-import { CARD_RELATED_TAGS } from '../../containers/App/constants';
-import { hasCardBasedScope } from '../../utils/common';
-import moment from 'moment';
-import { FONT_COLOR_05 } from '@capillarytech/cap-ui-library/styled/variables';
+import { CARD_RELATED_TAGS, HOSPITALITY_RELATED_TAGS } from '../../containers/App/constants';
+import { hasCardBasedScope, hasHospitalityBasedScope } from '../../utils/common';
+
 import {
   GET_TRANSLATION_MAPPED,
   JAPANESE_HELP_TEXT,
@@ -93,12 +94,12 @@ class CapTagList extends React.Component { // eslint-disable-line react/prefer-s
     let list = [];
     _.forEach(tags, (val = {}, key) => {
       if (_.has(val, 'subtags')) {
-        if ((val.name || '').toLowerCase().indexOf(value.toLowerCase()) !== -1) {
+        if (val.name && typeof val.name === 'string' && (val.name || '').toLowerCase().indexOf(value.toLowerCase()) !== -1) {
           list.push(key);
         }
         const temp = this.getSearchedExpandedKeys(val.subtags, value);
         list = list.concat(temp);
-      } else if ((val.name || '').toLowerCase().indexOf(value.toLowerCase()) !== -1) {
+      } else if (val.name && typeof val.name === 'string' && (val.name || '').toLowerCase().indexOf(value.toLowerCase()) !== -1) {
         list.push(key);
       }
     });
@@ -181,6 +182,10 @@ class CapTagList extends React.Component { // eslint-disable-line react/prefer-s
     if (!hasCardBasedScope()) {
       clonedTags = _.omit(clonedTags, CARD_RELATED_TAGS);
     }
+    if (!hasHospitalityBasedScope()) {
+      //filtering HOSPITALITY_RELATED_TAGS if org does not have HOSPITALITY_BASED_SCOPE feature enabled
+      clonedTags = _.omit(clonedTags, HOSPITALITY_RELATED_TAGS);
+    }
     _.forEach(clonedTags, (val = '', key) => {
       let supportedTagsString = '';
       _.forEach(val.supportedTags, (supportedTag) => {

package/v2Containers/ChannelTemplates/actions.js

@@ -0,0 +1,20 @@
+/*
+ *
+ * ChannelTemplates actions
+ *
+ */
+
+import * as types from './constants';
+
+export function defaultAction() {
+  return {
+    type: types.DEFAULT_ACTION,
+  };
+}
+
+export function getTemplates(channel) {
+  return {
+    type: types.GET_TEMPLATES_REQUEST,
+    channel,
+  };
+}

package/v2Containers/ChannelTemplates/constants.js

@@ -0,0 +1,8 @@
+/*
+ *
+ * ChannelTemplates constants
+ *
+ */
+
+export const DEFAULT_ACTION = 'app/ChannelTemplates/DEFAULT_ACTION';
+

package/v2Containers/ChannelTemplates/index.js

@@ -0,0 +1,47 @@
+/*
+ *
+ * ChannelTemplates
+ *
+ */
+
+import PropTypes from 'prop-types';
+
+import React from 'react';
+import { connect } from 'react-redux';
+import { FormattedMessage } from 'react-intl';
+import { bindActionCreators } from 'redux';
+import { createStructuredSelector } from 'reselect';
+import makeSelectChannelTemplates from './selectors';
+import * as actions from './actions';
+import messages from './messages';
+
+
+export class ChannelTemplates extends React.Component { // eslint-disable-line react/prefer-stateless-function
+  componentDidMount() {
+    this.props.actions.getTemplates(this.props.channel);
+  }
+  render() {
+    return (
+      <CardGrid
+        cardDataList={[]}
+      />
+    );
+  }
+}
+
+ChannelTemplates.propTypes = {
+  actions: PropTypes.object.isRequired,
+  channel: PropTypes.string,
+};
+
+const mapStateToProps = createStructuredSelector({
+  ChannelTemplates: makeSelectChannelTemplates(),
+});
+
+function mapDispatchToProps(dispatch) {
+  return {
+    actions: bindActionCreators(actions, dispatch),
+  };
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(ChannelTemplates);

package/v2Containers/ChannelTemplates/messages.js

@@ -0,0 +1,13 @@
+/*
+ * ChannelTemplates Messages
+ *
+ * This contains all the text for the ChannelTemplates component.
+ */
+import { defineMessages } from 'react-intl';
+
+export default defineMessages({
+  header: {
+    id: 'creatives.containersV2.ChannelTemplates.header',
+    defaultMessage: 'This is ChannelTemplates container !',
+  },
+});

package/v2Containers/ChannelTemplates/reducer.js

@@ -0,0 +1,34 @@
+/*
+ *
+ * ChannelTemplates reducer
+ *
+ */
+
+import { fromJS } from 'immutable';
+import * as types from './constants';
+
+const initialState = fromJS({
+  loadingTemplates: true,
+  smsTemplates: [],
+  emailTemplates: [],
+  wechatTemplates: [],
+  mobilepushTemplates: [],
+});
+
+function channelTemplatesReducer(state = initialState, action) {
+  const channelTemplates = `${action.channel}Templates`;
+  switch (action.type) {
+    case types.DEFAULT_ACTION:
+      return state;
+    case types.GET_TEMPLATES_REQUEST:
+      return state.set('loadingTemplates', true);
+    case types.GET_TEMPLATES_SUCESS:
+      return state.set('loadingTemplates', false).set(channelTemplates, action.templates);
+    case types.GET_TEMPLATES_FAILURE:
+      return state.set('loadingTemplates', false).set('error', action.error);
+    default:
+      return state;
+  }
+}
+
+export default channelTemplatesReducer;

package/v2Containers/ChannelTemplates/sagas.js

@@ -0,0 +1,32 @@
+import { take, takeLatest, call, put, cancel } from 'redux-saga/effects';
+import { LOCATION_CHANGE } from 'react-router-redux';
+import * as Api from '../../services/api';
+
+
+import * as types from './constants';
+// Individual exports for testing
+export function* defaultSaga() {
+  // See example in v2Containers/HomePage/sagas.js
+}
+function* getTemplates(action) {
+  try {
+    const req = {
+      channel: action.channel,
+      queryParams: action.query,
+    };
+    const res = call(Api.getAllTemplates, req);
+    put({type: types.GET_TEMPLATES_SUCESS, templates: res.response, channel: action.channel});
+  } catch (error) {
+    put({type: types.GET_TEMPLATES_FAILURE, error});
+  }
+}
+function* getTemplatesWatcher() {
+  const watcher = yield takeLatest(types.GET_TEMPLATES_REQUEST, getTemplates);
+  yield take(LOCATION_CHANGE);
+  yield cancel(watcher);
+}
+// All sagas to be loaded
+export default [
+  defaultSaga,
+  getTemplatesWatcher,
+];

package/v2Containers/ChannelTemplates/selectors.js

@@ -0,0 +1,25 @@
+import { createSelector } from 'reselect';
+
+/**
+ * Direct selector to the channelTemplates state domain
+ */
+const selectChannelTemplatesDomain = () => (state) => state.get('templates');
+
+/**
+ * Other specific selectors
+ */
+
+
+/**
+ * Default selector used by ChannelTemplates
+ */
+
+const makeSelectChannelTemplates = () => createSelector(
+  selectChannelTemplatesDomain(),
+  (substate) => substate.toJS()
+);
+
+export default makeSelectChannelTemplates;
+export {
+  selectChannelTemplatesDomain,
+};

package/v2Containers/Sms/Create/tests/sagas.test.js

@@ -0,0 +1,82 @@
+import { expectSaga } from "redux-saga-test-plan";
+import { take, cancel, takeLatest } from "redux-saga/effects";
+import * as matchers from "redux-saga-test-plan/matchers";
+import { LOCATION_CHANGE } from "react-router-redux";
+import { throwError } from "redux-saga-test-plan/providers";
+import { createMockTask } from "redux-saga/utils";
+import * as types from "../constants";
+import { watchAiSuggestions, getAiSuggestions } from "../sagas";
+import * as Api from "../../../../services/api";
+
+describe("getAiSuggestions saga", () => {
+  it("Should handle valid response from api", () => {
+    const successCallback = () => {};
+    const failureCallback = () => {};
+    const action = {
+      type: types.GET_AI_SUGGESTIONS,
+      prompt: {},
+      successCallback,
+      failureCallback,
+    };
+    expectSaga(getAiSuggestions, action)
+      .provide([
+        [
+          matchers.call.fn(Api.getAiSuggestions),
+          {
+            success: true,
+            status: {
+              isError: false,
+              code: 200,
+              message: "success",
+            },
+            message: "Meta data fetched successfully",
+            response: {
+              "https://response.com": 1400,
+            },
+          },
+        ],
+        [matchers.call.fn(successCallback)],
+      ])
+      .run();
+  });
+
+  it("Should handles error thrown from api", () => {
+    const successCallback = () => {};
+    const failureCallback = () => {};
+    const action = {
+      type: types.GET_AI_SUGGESTIONS,
+      prompt: {},
+      successCallback,
+      failureCallback,
+    };
+    expectSaga(getAiSuggestions, action)
+      .provide([[matchers.call.fn(Api.getAiSuggestions), throwError()]])
+      .run();
+  });
+});
+
+describe("watchAiSuggestions saga", () => {
+  let generator = null;
+  beforeEach(() => {
+    generator = watchAiSuggestions();
+  });
+  it("Should handle valid response from api", () => {
+    const progress1 = generator.next();
+    const mockTask = takeLatest(types.GET_AI_SUGGESTIONS, getAiSuggestions);
+    expect(progress1.value).toEqual(mockTask);
+    const progress2 = generator.next();
+    expect(progress2.value).toEqual(take(LOCATION_CHANGE));
+  });
+
+  it("Should handle LOCATION_CHANGE action and cancel the watcher", () => {
+    generator = watchAiSuggestions();
+    const mockTask = createMockTask();
+
+    expect(generator.next().value).toEqual(
+      takeLatest(types.GET_AI_SUGGESTIONS, getAiSuggestions)
+    );
+    expect(generator.next(mockTask).value).toEqual(take(LOCATION_CHANGE));
+    expect(generator.next().value).toEqual(cancel(mockTask));
+    expect(generator.next().done).toEqual(true);
+  });
+});

package/v2Containers/TagList/index.js

@@ -30,6 +30,7 @@ export class TagList extends React.Component { // eslint-disable-line react/pref
     super(props);
     this.state = {
       loading: false,
+      tags: []
     };
     this.renderTags = this.renderTags.bind(this);
     this.populateTags = this.populateTags.bind(this);
@@ -42,6 +43,34 @@ export class TagList extends React.Component { // eslint-disable-line react/pref
     
   }
 
+  componentDidUpdate(prevProps) {
+    if (this.props.tags !== prevProps.tags || this.props.injectedTags !== prevProps.injectedTags || this.props.selectedOfferDetails !== prevProps.selectedOfferDetails) {
+      this.setState({
+        tags: this.generateTags(this.props),
+      });
+    }
+  }
+
+  generateTags(props) {
+    let tags = {};
+    let injectedTags = {};
+    if (props.injectedTags && !_.isEmpty(props.injectedTags)) {
+      const formattedInjectedTags = handleInjectedData(
+        props.injectedTags,
+        scope
+      );
+      injectedTags = this.transformInjectedTags(formattedInjectedTags);
+    }
+    if (props.tags && props.tags.length > 0) {
+      tags = this.populateTags(props.tags);
+      console.log('populating tags', Object.keys(tags || {}).length);
+    }
+    if (props.selectedOfferDetails && !_.isEmpty(props.selectedOfferDetails) && (tags && tags.coupon)) {
+      this.transformCouponTags(props.selectedOfferDetails, tags);
+    }
+    return _.merge( {}, tags, injectedTags);
+  }
+
   componentWillReceiveProps(nextProps) {
     if (_.isEmpty(this.props.injectedTags) && _.isEmpty(this.props.tags)) {
       this.setState({loading: true});
@@ -54,6 +83,7 @@ export class TagList extends React.Component { // eslint-disable-line react/pref
       
       this.setState({loading: false});
     }
+
   }
 
   onSelect = (selectedKeys) => {
@@ -225,29 +255,11 @@ export class TagList extends React.Component { // eslint-disable-line react/pref
   }
 
   render() {
-    let tags = {};
-    let injectedTags = {};
-    if (this.props.injectedTags && !_.isEmpty(this.props.injectedTags)) {
-      const formattedInjectedTags = handleInjectedData(
-        this.props.injectedTags,
-        scope
-      );
-      injectedTags = this.transformInjectedTags(formattedInjectedTags);
-    }
-    if (this.props.tags && this.props.tags.length > 0) {
-      tags = this.populateTags(this.props.tags);
-      console.log('populating tags', Object.keys(tags || {}).length);
-    }
-    if (this.props.selectedOfferDetails && !_.isEmpty(this.props.selectedOfferDetails) && (tags && tags.coupon)) {
-      this.transformCouponTags(this.props.selectedOfferDetails, tags);
-    }
-    tags = _.merge( {}, tags, injectedTags);
-    console.log('merged tags', Object.keys(tags || {}).length);
     return (
       <div className={this.props.className ? this.props.className : ''}>
         <CapTagList
           loading={this.state.loading}
-          tags={tags}
+          tags={this.state.tags}
           onSelect={this.onSelect}
           label={this.props.label}
           visibleTaglist={this.props.visibleTaglist}