castled-js-sdk 0.0.1 → 0.0.3

package/src/integrations/CustomerIO/index.js

@@ -0,0 +1 @@
+export { CustomerIO } from './browser';

package/src/integrations/CustomerIO/nativeSdkLoader.js

@@ -0,0 +1,31 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(siteID, datacenterEU) {
+  window._cio = window._cio || [];
+  (function () {
+    let a;
+    let b;
+    let c;
+    a = function (f) {
+      return function () {
+        window._cio.push([f].concat(Array.prototype.slice.call(arguments, 0)));
+      };
+    };
+    b = ['load', 'identify', 'sidentify', 'track', 'page'];
+    for (c = 0; c < b.length; c++) {
+      window._cio[b[c]] = a(b[c]);
+    }
+    const t = document.createElement('script');
+    const s = document.getElementsByTagName('script')[0];
+    t.async = true;
+    t.setAttribute('data-loader', LOAD_ORIGIN);
+    t.id = 'cio-tracker';
+    t.setAttribute('data-site-id', siteID);
+    t.src = 'https://assets.customer.io/assets/track.js';
+    if (datacenterEU === true) {
+      t.src = 'https://assets.customer.io/assets/track-eu.js';
+    }
+    s.parentNode.insertBefore(t, s);
+  })();
+}
+export { loadNativeSdk };

package/src/integrations/DCMFloodlight/browser.js

@@ -0,0 +1,240 @@
+/* eslint-disable no-param-reassign */
+/* eslint-disable class-methods-use-this */
+import get from 'get-value';
+import logger from '../../utils/logUtil';
+import ScriptLoader from '../../utils/ScriptLoader';
+import { removeUndefinedAndNullValues } from '../../utils/commonUtils';
+import { NAME, GTAG } from './constants';
+import {
+  transformCustomVariable,
+  flattenPayload,
+  buildGtagTrackPayload,
+  buildIframeTrackPayload,
+  isValidCountingMethod,
+} from './utils';
+
+class DCMFloodlight {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.advertiserId = config.advertiserId;
+    this.activityTag = config.activityTag;
+    this.groupTag = config.groupTag;
+    this.conversionEvents = config.conversionEvents;
+    this.conversionLinker = config.conversionLinker;
+    this.allowAdPersonalizationSignals = config.allowAdPersonalizationSignals;
+    this.doubleclickId = config.doubleclickId;
+    this.googleNetworkId = config.googleNetworkId;
+    this.tagFormat = config.tagFormat || GTAG;
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  /**
+   * Ref - https://support.google.com/campaignmanager/answer/7554821
+   */
+  init() {
+    logger.debug('===In init DCMFloodlight===');
+
+    if (this.tagFormat === GTAG) {
+      const sourceUrl = `https://www.googletagmanager.com/gtag/js?id=DC-${this.advertiserId}`;
+      ScriptLoader('DCMFloodlight-integration', sourceUrl);
+
+      window.dataLayer = window.dataLayer || [];
+      window.gtag = function gtag() {
+        // eslint-disable-next-line prefer-rest-params
+        window.dataLayer.push(arguments);
+      };
+
+      // disable ad personalization
+      if (!this.allowAdPersonalizationSignals) {
+        window.gtag('set', 'allow_ad_personalization_signals', false);
+      }
+
+      window.gtag('js', new Date());
+
+      if (this.conversionLinker) {
+        window.gtag('config', `DC-${this.advertiserId}`);
+      } else {
+        window.gtag('config', `DC-${this.advertiserId}`, {
+          conversion_linker: false,
+        });
+      }
+    }
+
+    this.loadCookieMatching();
+  }
+
+  /**
+   * Google's cookie matching functionality
+   * Ref - https://developers.google.com/authorized-buyers/rtb/cookie-guide
+   */
+  loadCookieMatching() {
+    logger.debug('===In loadCookieMatching DCMFloodlight===');
+    if (this.doubleclickId && this.googleNetworkId) {
+      const image = document.createElement('img');
+      image.src = `https://cm.g.doubleclick.net/pixel?google_nid=${
+        this.googleNetworkId
+      }&google_hm=${btoa(this.analytics.getAnonymousId())}`;
+      document.getElementsByTagName('head')[0].appendChild(image);
+    }
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded DCMFloodlight===');
+    if (this.tagFormat === GTAG) {
+      return window.dataLayer.push !== Array.prototype.push;
+    }
+    return true;
+  }
+
+  isReady() {
+    logger.debug('===In isReady DCMFloodlight===');
+    if (this.tagFormat === GTAG) {
+      return window.dataLayer.push !== Array.prototype.push;
+    }
+    return true;
+  }
+
+  identify() {
+    logger.debug('[DCM Floodlight] identify:: method not supported');
+  }
+
+  track(htElement) {
+    logger.debug('===In DCMFloodlight track===');
+
+    const { message } = htElement;
+    const { event } = message;
+    let customFloodlightVariable;
+
+    if (!event) {
+      logger.error('[DCM Floodlight]:: event is required for track call');
+      return;
+    }
+
+    // Specifies how conversions will be counted for a Floodlight activity
+    let countingMethod = get(message, 'properties.countingMethod');
+    if (!countingMethod) {
+      logger.error('[DCM Floodlight]:: countingMethod is required for track call');
+      return;
+    }
+    countingMethod = countingMethod.trim().toLowerCase().replace(/\s+/g, '_');
+
+    // find conversion event
+    // knowing cat (activityTag), type (groupTag), (counter or sales), customVariable from config
+    const conversionEvent = this.conversionEvents.find(
+      (cnEvent) => cnEvent?.eventName?.trim().toLowerCase() === event.toLowerCase(),
+    );
+
+    if (!conversionEvent) {
+      logger.error('[DCM Floodlight]:: Conversion event not found');
+      return;
+    }
+
+    if (conversionEvent.floodlightActivityTag && conversionEvent.floodlightGroupTag) {
+      this.activityTag = conversionEvent.floodlightActivityTag.trim();
+      this.groupTag = conversionEvent.floodlightGroupTag.trim();
+    }
+
+    const { salesTag, customVariables } = conversionEvent;
+
+    if (!isValidCountingMethod(salesTag, countingMethod)) {
+      logger.error(
+        `[DCM Floodlight] ${salesTag ? 'Sales' : 'Counter'} Tag:: invalid counting method`,
+      );
+      return;
+    }
+
+    customFloodlightVariable = customVariables || [];
+    customFloodlightVariable = transformCustomVariable(customFloodlightVariable, message);
+
+    customFloodlightVariable = removeUndefinedAndNullValues(customFloodlightVariable);
+
+    if (this.tagFormat === GTAG) {
+      this.trackWithGtag(message, salesTag, customFloodlightVariable, countingMethod);
+    } else {
+      this.trackWithIframe(message, salesTag, customFloodlightVariable, countingMethod);
+    }
+  }
+
+  trackWithGtag(message, salesTag, customFloodlightVariable, countingMethod) {
+    logger.debug('===In DCMFloodlight trackWithGtag===');
+
+    let eventSnippetPayload = buildGtagTrackPayload(
+      message,
+      salesTag,
+      countingMethod,
+      this.analytics.loadOnlyIntegrations,
+    );
+
+    eventSnippetPayload = {
+      allow_custom_scripts: true,
+      ...eventSnippetPayload,
+      ...customFloodlightVariable,
+      send_to: `DC-${this.advertiserId}/${this.groupTag}/${this.activityTag}+${countingMethod}`,
+    };
+
+    eventSnippetPayload = removeUndefinedAndNullValues(eventSnippetPayload);
+    logger.debug(`[DCM] eventSnippetPayload:: ${JSON.stringify(eventSnippetPayload)}`);
+
+    // event snippet
+    // Ref - https://support.google.com/campaignmanager/answer/7554821#zippy=%2Cfields-in-the-event-snippet---overview
+    window.gtag('event', 'conversion', eventSnippetPayload);
+  }
+
+  trackWithIframe(message, salesTag, customFloodlightVariable, countingMethod) {
+    logger.debug('===In DCMFloodlight trackWithIframe===');
+    let eventSnippetPayload = buildIframeTrackPayload(
+      message,
+      salesTag,
+      countingMethod,
+      this.analytics.loadOnlyIntegrations,
+    );
+
+    eventSnippetPayload = {
+      ...eventSnippetPayload,
+      ...customFloodlightVariable,
+    };
+    eventSnippetPayload = removeUndefinedAndNullValues(eventSnippetPayload);
+    eventSnippetPayload = flattenPayload(eventSnippetPayload);
+    const src = `https://${this.advertiserId}.fls.doubleclick.net/activityi;src=${this.advertiserId};type=${this.groupTag};cat=${this.activityTag};${eventSnippetPayload}?`;
+    this.addIframe(src);
+  }
+
+  addIframe(src) {
+    logger.debug('===In DCMFloodlight addIframe===');
+    const iframe = document.createElement('iframe');
+    iframe.src = src;
+    iframe.style.width = '1px';
+    iframe.style.height = '1px';
+    iframe.style.display = 'none';
+    iframe.style.border = 0;
+    document.getElementsByTagName('body')[0].appendChild(iframe);
+  }
+
+  page(htElement) {
+    logger.debug('===In DCMFloodlight page===');
+    const { category } = htElement.message.properties;
+    const { name } = htElement.message || htElement.message.properties;
+
+    if (!category && !name) {
+      logger.error('[DCM Floodlight]:: category or name is required for page');
+      return;
+    }
+
+    const categoryVal = category ? `${category} ` : '';
+    const nameVal = name ? `${name} ` : '';
+    htElement.message.event = `Viewed ${categoryVal}${nameVal}Page`;
+
+    htElement.message.type = 'track';
+    this.track(htElement);
+  }
+}
+
+export default DCMFloodlight;

package/src/integrations/DCMFloodlight/constants.js

@@ -0,0 +1,15 @@
+const NAME = 'DCM_FLOODLIGHT';
+const CNameMapping = {
+  [NAME]: NAME,
+  'DCM Floodlight': NAME,
+  'dcm floodlight': NAME,
+  'Dcm Floodlight': NAME,
+  DCMFloodlight: NAME,
+  dcmfloodlight: NAME,
+  DcmFloodlight: NAME,
+  dcm_floodlight: NAME,
+  DCM_Floodlight: NAME,
+};
+const GTAG = 'globalSiteTag';
+
+export { NAME, CNameMapping, GTAG };

package/src/integrations/DCMFloodlight/index.js

@@ -0,0 +1 @@
+export { default as DCMFloodlight } from './browser';

package/src/integrations/DCMFloodlight/utils.js

@@ -0,0 +1,336 @@
+import get from 'get-value';
+import { GENERIC_FALSE_VALUES, GENERIC_TRUE_VALUES } from '../../utils/constants';
+import logger from '../../utils/logUtil';
+import {
+  isNotEmpty,
+  isDefinedAndNotNull,
+  isDefinedNotNullNotEmpty,
+  removeUndefinedAndNullValues,
+} from '../../utils/commonUtils';
+
+const matchIdKey = 'properties.matchId';
+
+/**
+ * transform webapp dynamicForm custom floodlight variable
+ * [
+      {
+        "from": "property1",
+        "to": "1"
+      },
+      {
+        "from": "property2",
+        "to": "2"
+      }
+  ]
+ * into { property1: u1, property2: u2, ... }
+ * Ref - https://support.google.com/campaignmanager/answer/2823222?hl=en
+ * @param {*} customFloodlightVariable
+ * @returns
+ */
+const transformCustomVariable = (customFloodlightVariable, message) => {
+  const customVariable = {};
+  const DENIED_CHARACTERS = ['"', '<', '>', '#'];
+  customFloodlightVariable.forEach((item) => {
+    if (item && isNotEmpty(item.from) && isNotEmpty(item.to)) {
+      // remove u if already there
+      // first we consider taking custom variable from properties
+      // if not found we will take it from traits
+      let itemValue = get(message, `properties.${item.from.trim()}`);
+      // this condition adds support for numeric 0
+      if (!isDefinedAndNotNull(itemValue)) {
+        const traits = message.traits || message.context?.traits;
+        if (traits) {
+          itemValue = traits[item.from.trim()];
+        }
+      }
+      if (
+        itemValue &&
+        typeof itemValue === 'string' &&
+        DENIED_CHARACTERS.some((key) => itemValue.includes(key))
+      ) {
+        logger.info(`${DENIED_CHARACTERS} string variable is not acceptable`);
+        itemValue = undefined;
+      }
+      // supported data types are number and string
+      if (isDefinedAndNotNull(itemValue) && typeof itemValue !== 'boolean') {
+        customVariable[`u${item.to.trim().replace(/u/g, '')}`] = encodeURIComponent(itemValue);
+      }
+    }
+  });
+
+  return customVariable;
+};
+
+/**
+ * @param {*} payload {"a":1,"b":"xyz"}
+ * @returns a=1;b=xyz
+ */
+const flattenPayload = (payload) => {
+  let rawPayload = '';
+  Object.entries(payload).forEach(([key, value]) => {
+    if (key && isDefinedNotNullNotEmpty(value)) {
+      rawPayload += `${key}=${value};`;
+    }
+  });
+  return rawPayload.replace(/.$/, '');
+};
+
+// valid flag should be provided [1|true] or [0|false]
+const mapFlagValue = (key, value) => {
+  if (GENERIC_TRUE_VALUES.includes(value.toString())) {
+    return 1;
+  }
+  if (GENERIC_FALSE_VALUES.includes(value.toString())) {
+    return 0;
+  }
+
+  throw Error(`[DCM Floodlight]:: ${key}: valid parameters are [1|true] or [0|false]`);
+};
+
+const calculateQuantity = (products) => {
+  if (products && products.length > 0 && Array.isArray(products)) {
+    return products.reduce((accumulator, product) => {
+      if (product.quantity) {
+        return accumulator + product.quantity;
+      }
+      return accumulator;
+    }, 0);
+  }
+  return 0;
+};
+
+const isValidCountingMethod = (salesTag, countingMethod) => {
+  // sales tag
+  if (salesTag) {
+    if (countingMethod === 'transactions' || countingMethod === 'items_sold') {
+      return true;
+    }
+  }
+  // counter tag
+  else if (
+    countingMethod === 'standard' ||
+    countingMethod === 'unique' ||
+    countingMethod === 'per_session'
+  ) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ * Function to build custom params using integrations object
+ * {
+  "integrations": {
+    "All": true,
+    "DCM_Floodlight": {
+      "COPPA": "false",
+      "GDPR": "1",
+      "npa": true
+    }
+  }
+}
+ * @param {*} message
+ * @param {*} integrationObj
+ * @returns // {"tag_for_child_directed_treatment":0,"tfua":1,"npa":1}
+ */
+const buildCustomParamsUsingIntegrationsObject = (message, integrationObj) => {
+  const customParams = {};
+  // COPPA, GDPR, npa must be provided inside integration object
+  let { DCM_FLOODLIGHT } = message.integrations;
+  if (!DCM_FLOODLIGHT) {
+    ({ DCM_FLOODLIGHT } = integrationObj);
+  }
+
+  if (DCM_FLOODLIGHT) {
+    if (isDefinedNotNullNotEmpty(DCM_FLOODLIGHT.COPPA)) {
+      customParams.tag_for_child_directed_treatment = mapFlagValue('COPPA', DCM_FLOODLIGHT.COPPA);
+    }
+
+    if (isDefinedNotNullNotEmpty(DCM_FLOODLIGHT.GDPR)) {
+      customParams.tfua = mapFlagValue('GDPR', DCM_FLOODLIGHT.GDPR);
+    }
+
+    if (isDefinedNotNullNotEmpty(DCM_FLOODLIGHT.npa)) {
+      customParams.npa = mapFlagValue('npa', DCM_FLOODLIGHT.npa);
+    }
+  }
+
+  const matchId = get(message, matchIdKey);
+  if (matchId) {
+    customParams.match_id = matchId;
+  }
+
+  return customParams;
+};
+
+/**
+ * Generate a cryptographically secure random number between 0 and 9999999999999
+ * @returns
+ */
+const getRandomNumber = () => Math.random() * 10000000000000;
+
+/**
+ * Returns quantity parameter
+ * @param {*} message
+ * @returns
+ */
+const getQuantity = (message) => {
+  const qty = get(message, 'properties.quantity');
+  const products = get(message, 'properties.products');
+  const quantities = calculateQuantity(products);
+  return quantities || qty;
+};
+
+const buildGtagTrackPayload = (message, salesTag, countingMethod, integrationObj) => {
+  // Ref - https://support.google.com/campaignmanager/answer/7554821?hl=en#zippy=%2Ccustom-fields
+  // we can pass custom variables to DCM and any values passed in it will override its default value
+  // Total 7 properties - ord, num, dc_lat, tag_for_child_directed_treatment, tfua, npa, match_id
+  let dcCustomParams = {};
+  let eventSnippetPayload = {};
+
+  if (salesTag) {
+    // sales tag
+    dcCustomParams.ord = get(message, 'properties.orderId') || get(message, 'properties.order_id');
+
+    eventSnippetPayload = {
+      ...eventSnippetPayload,
+      value: get(message, 'properties.revenue'),
+      transaction_id: dcCustomParams.ord,
+    };
+
+    // Ref - https://support.google.com/campaignmanager/answer/7554821#zippy=%2Cfields-in-event-snippets-for-sales-tags
+    // possible values for counting method :- transactions, items_sold
+    const qty = getQuantity(message);
+    if (countingMethod === 'items_sold' && qty) {
+      eventSnippetPayload.quantity = parseFloat(qty);
+    }
+  } else {
+    // counter tag
+    // Ref - https://support.google.com/campaignmanager/answer/7554821#zippy=%2Cfields-in-event-snippets-for-counter-tags
+    switch (countingMethod) {
+      case 'standard':
+        dcCustomParams.ord = get(message, 'properties.ord');
+        break;
+      case 'unique':
+        dcCustomParams.num = get(message, 'properties.num');
+        break;
+      case 'per_session':
+        dcCustomParams.ord = get(message, 'properties.sessionId');
+        eventSnippetPayload.session_id = dcCustomParams.ord;
+        break;
+      default:
+        break;
+    }
+  }
+
+  dcCustomParams = {
+    ...dcCustomParams,
+    ...buildCustomParamsUsingIntegrationsObject(message, integrationObj),
+  };
+
+  const dcLat = get(message, 'context.device.adTrackingEnabled');
+  const matchId = get(message, matchIdKey);
+
+  if (isDefinedNotNullNotEmpty(dcLat)) {
+    dcCustomParams.dc_lat = mapFlagValue('dc_lat', dcLat);
+  }
+  if (matchId) {
+    dcCustomParams.match_id = matchId;
+  }
+
+  dcCustomParams = removeUndefinedAndNullValues(dcCustomParams);
+  if (Object.keys(dcCustomParams).length > 0) {
+    eventSnippetPayload.dc_custom_params = dcCustomParams;
+  }
+  return eventSnippetPayload;
+};
+
+/**
+ * Returns customParams for sales tag
+ * @param {*} message
+ * @param {*} countingMethod
+ * @returns
+ */
+const buildCustomParamsForSalesTag = (message, countingMethod) => {
+  const customParams = {
+    ord: get(message, 'properties.orderId') || get(message, 'properties.order_id'),
+    cost: get(message, 'properties.revenue'),
+  };
+
+  // Ref - https://support.google.com/campaignmanager/answer/2823450?hl=en#zippy=%2Chow-the-ord-parameter-is-displayed-for-each-counter-type%2Csales-activity-tags
+  if (countingMethod === 'transactions') {
+    customParams.qty = 1;
+  } else {
+    const qty = getQuantity(message);
+    if (qty) {
+      customParams.qty = parseFloat(qty);
+    }
+  }
+
+  return customParams;
+};
+
+/**
+ * Returns customParams for counter tag
+ * @param {*} message
+ * @param {*} countingMethod
+ * @returns
+ */
+const buildCustomParamsForCounterTag = (message, countingMethod) => {
+  const customParams = {};
+
+  const randomNumber = getRandomNumber();
+  // Ref - https://support.google.com/campaignmanager/answer/2823450?hl=en#zippy=%2Ccounter-activity-tags%2Chow-the-ord-parameter-is-displayed-for-each-counter-type
+  switch (countingMethod) {
+    case 'standard':
+      customParams.ord = get(message, 'properties.ord') || randomNumber;
+      break;
+    case 'unique':
+      customParams.ord = 1;
+      customParams.num = get(message, 'properties.num') || randomNumber;
+      break;
+    case 'per_session':
+      customParams.ord = get(message, 'properties.sessionId');
+      break;
+    default:
+      break;
+  }
+
+  return customParams;
+};
+
+const buildIframeTrackPayload = (message, salesTag, countingMethod, integrationObj) => {
+  // Ref - https://support.google.com/campaignmanager/answer/2823450?hl=en#zippy=%2Cother-parameters-for-iframe-and-image-tags:~:text=Other%20parameters%20for%20iFrame%20and%20image%20tags
+  // we can pass custom params to DCM.
+  // Total 9 params - ord, num, cost, qty, dc_lat, tag_for_child_directed_treatment, tfua, npa, match_id
+  let customParams = salesTag
+    ? buildCustomParamsForSalesTag(message, countingMethod)
+    : buildCustomParamsForCounterTag(message, countingMethod);
+
+  customParams = {
+    ...customParams,
+    ...buildCustomParamsUsingIntegrationsObject(message, integrationObj),
+  };
+
+  const dcLat = get(message, 'context.device.adTrackingEnabled');
+  const matchId = get(message, matchIdKey);
+
+  if (isDefinedNotNullNotEmpty(dcLat)) {
+    customParams.dc_lat = mapFlagValue('dc_lat', dcLat);
+  }
+  if (matchId) {
+    customParams.match_id = matchId;
+  }
+
+  return customParams;
+};
+
+export {
+  mapFlagValue,
+  flattenPayload,
+  isValidCountingMethod,
+  buildGtagTrackPayload,
+  buildIframeTrackPayload,
+  transformCustomVariable,
+};