castled-js-sdk 0.0.1 → 0.0.2

package/src/integrations/SnapPixel/util.js

@@ -0,0 +1,211 @@
+import get from 'get-value';
+import sha256 from 'crypto-js/sha256';
+import logger from '../../utils/logUtil';
+import {
+  isNotEmpty,
+  isDefinedAndNotNull,
+  removeUndefinedAndNullValues,
+} from '../../utils/commonUtils';
+
+const orderIdKey = 'properties.order_id';
+const itemIdKey = 'properties.item_ids';
+const productsKey = 'properties.products';
+const productIdKey = 'properties.product_id';
+const productIdNotPresentMessage = 'product_id is not present';
+
+const eventSpecificPayloadMap = {
+  'order completed': {
+    itemIdsKey: productsKey,
+    transactionIdKey: orderIdKey,
+  },
+  'checkout started': {
+    itemIdsKey: productsKey,
+    transactionIdKey: orderIdKey,
+  },
+  'product added': {
+    itemIdsKey: productIdKey,
+  },
+  'payment info entered': {
+    itemIdsKey: itemIdKey,
+    transactionIdKey: 'properties.checkout_id',
+  },
+  'promotion clicked': {
+    itemIdsKey: itemIdKey,
+  },
+  'promotion viewed': {
+    itemIdsKey: itemIdKey,
+  },
+  'product added to wishlist': {
+    itemIdsKey: productIdKey,
+  },
+  'product viewed': {
+    itemIdsKey: productIdKey,
+  },
+  'product list viewed': {
+    itemIdsKey: productsKey,
+  },
+  'products searched': {
+    itemIdsKey: itemIdKey,
+    searchStringKey: 'properties.query',
+  },
+};
+
+const sendEvent = (event, payload) => {
+  if (isNotEmpty(payload)) {
+    window.snaptr('track', event, payload);
+  } else {
+    window.snaptr('track', event);
+  }
+};
+
+const getCommonEventPayload = (message, deduplicationKey, enableDeduplication) => {
+  let payload = {
+    price: parseFloat(
+      get(message, 'properties.price') ||
+        get(message, 'properties.value') ||
+        get(message, 'properties.revenue'),
+    ),
+    client_deduplication_id: get(message, 'properties.client_deduplication_id'),
+    currency: get(message, 'properties.currency'),
+    transaction_id:
+      get(message, 'properties.transactionId') || get(message, 'properties.transaction_id'),
+    item_category: get(message, 'properties.category'),
+    description: get(message, 'properties.description'),
+    search_string: get(message, 'properties.search_string'),
+    number_items: parseInt(
+      get(message, 'properties.number_items') || get(message, 'properties.quantity'),
+      10,
+    ),
+    payment_info_available: parseInt(get(message, 'properties.payment_info_available'), 10),
+    sign_up_method: get(message, 'properties.sign_up_method'),
+    success: parseInt(get(message, 'properties.success'), 10),
+  };
+  if (payload.payment_info_available !== 0 && payload.payment_info_available !== 1) {
+    payload.payment_info_available = null;
+  }
+  if (payload.success !== 0 && payload.success !== 1) {
+    payload.success = null;
+  }
+  if (enableDeduplication) {
+    payload.client_deduplication_id = get(message, `${deduplicationKey || 'messageId'}`);
+  }
+
+  payload = removeUndefinedAndNullValues(payload);
+  return payload;
+};
+
+const eventPayload = (message, deduplicationKey, enableDeduplication) => {
+  let payload = getCommonEventPayload(message, deduplicationKey, enableDeduplication);
+  payload.item_ids = get(message, itemIdKey);
+  payload = removeUndefinedAndNullValues(payload);
+  return payload;
+};
+
+/**
+ * Returns productIds
+ * @param {*} message
+ * @returns
+ */
+const getItemIds = (message) => {
+  let itemIds = [];
+  const products = get(message, productsKey);
+  if (products && Array.isArray(products)) {
+    products.forEach((element, index) => {
+      const productId = element.product_id;
+      if (productId) {
+        itemIds.push(productId);
+      } else {
+        logger.debug(`product_id not present for product at index ${index}`);
+      }
+    });
+  } else {
+    itemIds = null;
+  }
+  return itemIds;
+};
+
+/**
+ * Returns productId
+ * @param {*} message
+ * @returns
+ */
+const getItemId = (message) => {
+  let itemIds = [];
+  const productId = get(message, productIdKey);
+  if (isDefinedAndNotNull(productId)) {
+    itemIds.push(productId);
+  } else {
+    logger.debug(productIdNotPresentMessage);
+    itemIds = null;
+  }
+  return itemIds;
+};
+
+/**
+ * Returns ecom events payload
+ * @param {*} event
+ * @param {*} message
+ * @param {*} deduplicationKey
+ * @param {*} enableDeduplication
+ * @returns
+ */
+const ecommEventPayload = (event, message, deduplicationKey, enableDeduplication) => {
+  const eventName = event.toLowerCase().trim();
+  const specificPayload = eventSpecificPayloadMap[eventName];
+  let payload = getCommonEventPayload(message, deduplicationKey, enableDeduplication);
+
+  if (specificPayload) {
+    const { itemIdsKey, transactionIdKey, searchStringKey } = specificPayload;
+    let itemIds = [];
+
+    if (itemIdsKey === productsKey) {
+      itemIds = getItemIds(message);
+    } else if (itemIdsKey === productIdKey) {
+      itemIds = getItemId(message);
+    } else {
+      itemIds = get(message, itemIdsKey);
+    }
+
+    payload = {
+      ...payload,
+      item_ids: itemIds,
+    };
+
+    if (transactionIdKey) {
+      payload.transaction_id = get(message, transactionIdKey);
+    }
+
+    if (searchStringKey) {
+      payload.search_string = get(message, searchStringKey);
+    }
+  }
+  payload = removeUndefinedAndNullValues(payload);
+  return payload;
+};
+
+/*
+ Here, We take user parameters in payload i.e. userEmail and userPhoneNumber and hashMethod, so if hashMethod is `sha256`, 
+ then we convert the userEmail and userPhoneNumber to user_hashed_email and user_hashed_phone_number respectively in `sha256` format.
+ Otherwise if hashMethod not in `sha256` then we pass the userEmail and userPhoneNumber as user_email and user_phone_number respectively.
+*/
+const getUserEmailAndPhone = (hashMethod, userEmail, userPhoneNumber) => {
+  const payload = {};
+  if (hashMethod === 'sha256') {
+    if (userEmail) {
+      payload.user_hashed_email = sha256(userEmail).toString();
+    }
+    if (userPhoneNumber) {
+      payload.user_hashed_phone_number = sha256(userPhoneNumber).toString();
+    }
+  } else {
+    if (userEmail) {
+      payload.user_email = userEmail;
+    }
+    if (userPhoneNumber) {
+      payload.user_phone_number = userPhoneNumber;
+    }
+  }
+  return payload;
+};
+
+export { sendEvent, ecommEventPayload, eventPayload, getUserEmailAndPhone };

package/src/integrations/TVSquared/browser.js

@@ -0,0 +1,96 @@
+/* eslint-disable func-names */
+/* eslint-disable no-unused-vars */
+/* eslint-disable class-methods-use-this */
+/* eslint-disable no-underscore-dangle */
+import ScriptLoader from '../../utils/ScriptLoader';
+import { getAction } from './utils';
+import logger from '../../utils/logUtil';
+import { NAME } from './constants';
+
+class TVSquared {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.analytics = analytics;
+    this.brandId = config.brandId;
+    this.clientId = config.clientId;
+    this.eventWhiteList = config.eventWhiteList || [];
+    this.customMetrics = config.customMetrics || [];
+    this.name = NAME;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===in init TVSquared===');
+    window._tvq = window._tvq || [];
+    let url = document.location.protocol === 'https:' ? 'https://' : 'http://';
+    url += `collector-${this.clientId}.tvsquared.com/`;
+    window._tvq.push(['setSiteId', this.brandId]);
+    window._tvq.push(['setTrackerUrl', `${url}tv2track.php`]);
+    ScriptLoader('TVSquared-integration', `${url}tv2track.js`);
+  }
+
+  isLoaded() {
+    logger.debug('in TVSqaured isLoaded');
+    return !!(window._tvq && window._tvq.push !== Array.prototype.push);
+  }
+
+  isReady() {
+    logger.debug('in TVSqaured isReady');
+    return !!(window._tvq && window._tvq.push !== Array.prototype.push);
+  }
+
+  page(htElement) {
+    window._tvq.push([
+      function () {
+        this.deleteCustomVariable(5, 'page');
+      },
+    ]);
+    window._tvq.push(['trackPageView']);
+  }
+
+  track(htElement) {
+    const { message } = htElement;
+    const { event, userId, anonymousId } = message;
+
+    const whitelistEvents = this.eventWhiteList.filter((wl) => wl.event !== '');
+
+    const isEventInWhiteList = whitelistEvents.some(
+      (whitelistEvent) => whitelistEvent.event.toUpperCase() === event.toUpperCase(),
+    );
+
+    if (!isEventInWhiteList) {
+      return;
+    }
+
+    const session = { user: userId || anonymousId || '' };
+    const action = getAction(message, this.customMetrics);
+
+    window._tvq.push([
+      function () {
+        this.setCustomVariable(5, 'session', JSON.stringify(session), 'visit');
+      },
+    ]);
+
+    if (event.toUpperCase() !== 'RESPONSE') {
+      window._tvq.push([
+        function () {
+          this.setCustomVariable(5, event, JSON.stringify(action), 'page');
+        },
+      ]);
+      window._tvq.push(['trackPageView']);
+    } else {
+      window._tvq.push([
+        function () {
+          this.deleteCustomVariable(5, 'page');
+        },
+      ]);
+    }
+  }
+}
+export default TVSquared;

package/src/integrations/TVSquared/constants.js

@@ -0,0 +1,14 @@
+const NAME = 'TVSQUARED';
+const CNameMapping = {
+  [NAME]: NAME,
+  TVSquared: NAME,
+  tvsquared: NAME,
+  tvSquared: NAME,
+  TvSquared: NAME,
+  Tvsquared: NAME,
+  'TV Squared': NAME,
+  'tv squared': NAME,
+  'tv Squared': NAME,
+};
+
+export { NAME, CNameMapping };

package/src/integrations/TVSquared/index.js

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

package/src/integrations/TVSquared/utils.js

@@ -0,0 +1,40 @@
+/**
+ * Returns formatted revenue
+ * @param {*} revenue
+ * @returns
+ */
+const formatRevenue = (revenue) => parseFloat(revenue.toString().replace(/^[^\d.]*/, ''));
+
+/**
+ * Returns action object
+ * @param {*} message
+ * @param {*} metrics
+ */
+const getAction = (message, metrics) => {
+  const { properties } = message;
+  const {
+    revenue,
+    productType,
+    category,
+    order_id: orderId,
+    promotion_id: promotionId,
+  } = properties;
+
+  const action = {
+    rev: revenue ? formatRevenue(revenue) : '',
+    prod: category || productType || '',
+    id: orderId || '',
+    promo: promotionId || '',
+  };
+
+  const customMetrics = metrics.filter((m) => m.propertyName !== '');
+  customMetrics.forEach((customMetric) => {
+    const key = customMetric.propertyName;
+    const value = properties[key];
+    if (value) {
+      action[key] = value;
+    }
+  });
+};
+
+export { getAction, formatRevenue };

package/src/integrations/TiktokAds/browser.js

@@ -0,0 +1,103 @@
+/* eslint-disable no-unused-vars */
+/* eslint-disable class-methods-use-this */
+import logger from '../../utils/logUtil';
+import { NAME, eventNameMapping } from './constants';
+import {
+  isDefinedAndNotNull,
+  getDestinationExternalID,
+  getHashFromArrayWithDuplicate,
+} from '../../utils/commonUtils';
+import { getTrackResponse } from './util';
+import { loadNativeSdk } from './nativeSdkLoader';
+
+// Docs : https://ads.tiktok.com/gateway/docs/index
+class TiktokAds {
+  constructor(config, analytics, destinationInfo) {
+    if (analytics.logLevel) {
+      logger.setLogLevel(analytics.logLevel);
+    }
+    this.name = NAME;
+    this.analytics = analytics;
+    this.eventsToStandard = config.eventsToStandard;
+    this.pixelCode = config.pixelCode;
+    ({
+      shouldApplyDeviceModeTransformation: this.shouldApplyDeviceModeTransformation,
+      propagateEventsUntransformedOnError: this.propagateEventsUntransformedOnError,
+      destinationId: this.destinationId,
+    } = destinationInfo ?? {});
+  }
+
+  init() {
+    logger.debug('===In init Tiktok Ads===');
+    loadNativeSdk(this.pixelCode);
+  }
+
+  isLoaded() {
+    logger.debug('===In isLoaded Tiktok Ads===');
+    return !!window.ttq;
+  }
+
+  isReady() {
+    logger.debug('===In isReady Tiktok Ads===');
+    return !!window.ttq;
+  }
+
+  identify(htElement) {
+    logger.debug('===In Tiktok Ads Identify===');
+    const { message } = htElement;
+    const { traits } = message.context;
+    const { email, phone, number } = traits;
+    const payload = {};
+    if (isDefinedAndNotNull(email)) {
+      payload.email = email;
+    }
+    if (isDefinedAndNotNull(phone) || isDefinedAndNotNull(number)) {
+      payload.phone = phone || number;
+    }
+    if (Object.keys(payload).length > 0) {
+      const externalId = getDestinationExternalID(message, 'tiktokExternalId');
+      if (isDefinedAndNotNull(externalId)) {
+        window.ttq.identify(externalId, payload);
+      } else {
+        window.ttq.identify(payload);
+      }
+    }
+  }
+
+  track(htElement) {
+    logger.debug('===In Tiktok Ads Track===');
+    const { message } = htElement;
+    let event = message?.event;
+    if (!event) {
+      logger.error('Event name is required');
+      return;
+    }
+    event = event.toLowerCase().trim();
+    const standardEventsMap = getHashFromArrayWithDuplicate(this.eventsToStandard);
+    if (eventNameMapping[event] === undefined && !standardEventsMap[event]) {
+      logger.error(`Event name (${event}) is not valid, must be mapped to one of standard events`);
+      return;
+    }
+    if (standardEventsMap[event]) {
+      Object.keys(standardEventsMap).forEach((key) => {
+        if (key === event) {
+          standardEventsMap[event].forEach((eventName) => {
+            const updatedProperties = getTrackResponse(message);
+            window.ttq.track(eventName, updatedProperties);
+          });
+        }
+      });
+    } else {
+      event = eventNameMapping[event];
+      const updatedProperties = getTrackResponse(message);
+      window.ttq.track(event, updatedProperties);
+    }
+  }
+
+  page(htElement) {
+    logger.debug('===In Tiktok Ads Page===');
+    window.ttq.page();
+  }
+}
+
+export default TiktokAds;

package/src/integrations/TiktokAds/constants.js

@@ -0,0 +1,86 @@
+const NAME = 'TIKTOK_ADS';
+const CNameMapping = {
+  [NAME]: NAME,
+  TiktokAds: NAME,
+  TIKTOK_ADS: NAME,
+  "Tiktok ads": NAME,
+  "Tiktok Ads": NAME,
+  "Tik Tok Ads": NAME,
+  "tik tok ads": NAME,
+  tiktokads: NAME
+};
+const PARTNER_NAME = 'RudderStack';
+
+const trackMapping = [
+  {
+    "destKey": "event_id",
+    "sourceKeys": "properties.eventId"
+  },
+  {
+    "destKey": "test_event_code",
+    "sourceKeys": "testEventCode"
+  },
+  {
+    "destKey": "contents",
+    "sourceKeys": "properties.contents"
+  },
+  {
+    "destKey": "content_category",
+    "sourceKeys": "properties.category"
+  },
+  {
+    "destKey": "status",
+    "sourceKeys": "properties.status"
+  },
+  {
+    "destKey": "content_name",
+    "sourceKeys": "properties.name"
+  },
+  {
+    "destKey": "content_id",
+    "sourceKeys": ["properties.product_id", "properties.productId"]
+  },
+  {
+    "destKey": "content_type",
+    "sourceKeys": ["properties.contentType", "properties.content_type"]
+  },
+  {
+    "destKey": "currency",
+    "sourceKeys": "properties.currency"
+  },
+  {
+    "destKey": "value",
+    "sourceKeys": "properties.value"
+  },
+  {
+    "destKey": "description",
+    "sourceKeys": "properties.description"
+  },
+  {
+    "destKey": "email",
+    "sourceKeys": ["context.traits.email", "traits.email", "properties.email"]
+  },
+  {
+    "destKey": "phone",
+    "sourceKeys": ["context.traits.phone", "traits.phone", "properties.phone"]
+  }
+];
+const eventNameMapping = {
+  'product added to wishlist': 'AddToWishlist',
+  'product added': 'AddToCart',
+  'checkout started': 'InitiateCheckout',
+  'payment info entered': 'AddPaymentInfo',
+  'checkout step completed': 'CompletePayment',
+  'order completed': 'PlaceAnOrder',
+  viewcontent: 'ViewContent',
+  clickbutton: 'ClickButton',
+  search: 'Search',
+  contact: 'Contact',
+  download: 'Download',
+  submitform: 'SubmitForm',
+  completeregistration: 'CompleteRegistration',
+  subscribe: 'Subscribe',
+};
+
+
+export { NAME, CNameMapping, PARTNER_NAME, trackMapping, eventNameMapping };

package/src/integrations/TiktokAds/index.js

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

package/src/integrations/TiktokAds/nativeSdkLoader.js

@@ -0,0 +1,52 @@
+import { LOAD_ORIGIN } from '../../utils/ScriptLoader';
+
+function loadNativeSdk(pixelCode) {
+  !(function (w, d, t) {
+    w.TiktokAnalyticsObject = t;
+    var ttq = (w[t] = w[t] || []);
+    (ttq.methods = [
+      'page',
+      'track',
+      'identify',
+      'instances',
+      'debug',
+      'on',
+      'off',
+      'once',
+      'ready',
+      'alias',
+      'group',
+      'enableCookie',
+      'disableCookie',
+    ]),
+      (ttq.setAndDefer = function (t, e) {
+        t[e] = function () {
+          t.push([e].concat(Array.prototype.slice.call(arguments, 0)));
+        };
+      });
+    for (var i = 0; i < ttq.methods.length; i++) ttq.setAndDefer(ttq, ttq.methods[i]);
+    (ttq.instance = function (t) {
+      for (var e = ttq._i[t] || [], n = 0; n < ttq.methods.length; n++)
+        ttq.setAndDefer(e, ttq.methods[n]);
+      return e;
+    }),
+      (ttq.load = function (e, n) {
+        var i = 'https://analytics.tiktok.com/i18n/pixel/events.js';
+        (ttq._i = ttq._i || {}),
+          (ttq._i[e] = []),
+          (ttq._i[e]._u = i),
+          (ttq._t = ttq._t || {}),
+          (ttq._t[e] = +new Date()),
+          (ttq._o = ttq._o || {}),
+          (ttq._o[e] = n || {});
+        var o = document.createElement('script');
+        o.setAttribute('data-loader', LOAD_ORIGIN);
+        (o.type = 'text/javascript'), (o.async = !0), (o.src = i + '?sdkid=' + e + '&lib=' + t);
+        var a = document.getElementsByTagName('script')[0];
+        a.parentNode.insertBefore(o, a);
+      });
+  })(window, document, 'ttq');
+  ttq.load(pixelCode);
+}
+
+export { loadNativeSdk };

package/src/integrations/TiktokAds/util.js

@@ -0,0 +1,71 @@
+import { constructPayload } from '../../utils/utils';
+import { PARTNER_NAME, trackMapping } from './constants';
+import { removeUndefinedAndNullValues } from '../../utils/commonUtils';
+
+const getContents = (message) => {
+    let contents = [];
+    const { properties } = message;
+    // eslint-disable-next-line camelcase
+    const { products, content_type, contentType } = properties;
+    if (Array.isArray(products)) {
+        contents = products.map(product => {
+            const singleProduct = {
+                content_type:
+                    // eslint-disable-next-line camelcase
+                    product.contentType || contentType || product.content_type || content_type || 'product',
+                content_id: product.product_id,
+                content_category: product.category,
+                content_name: product.name,
+                price: product.price,
+                quantity: product.quantity,
+                description: product.description,
+            };
+            return removeUndefinedAndNullValues(singleProduct);
+        });
+    }
+    return contents;
+};
+
+
+const checkContentType = (contents, contentType) => {
+    let transformedContents = contents;
+    if (Array.isArray(contents)) {
+        transformedContents = contents.map((content) => {
+            const transformedContent = { ...content }
+            if (!content.content_type) {
+                transformedContent.content_type = contentType || 'product_group';
+            }
+            return transformedContent;
+        });
+    }
+    return transformedContents;
+};
+const getTrackResponse = (message) => {
+    let properties = constructPayload(message, trackMapping); // constructing properties
+
+    // if contents is not an array
+    if (properties?.contents && !Array.isArray(properties.contents)) {
+        properties.contents = [properties.contents];
+    }
+
+    if (properties && !properties?.contents && message.properties?.products) {
+        // retreiving data from products only when contents is not present
+        properties = {
+            ...properties,
+            contents: getContents(message),
+        };
+    }
+
+    if (properties?.contents) {
+        properties.contents = checkContentType(
+            properties?.contents,
+            message.properties?.contentType,
+        );
+    }
+    // add partner name
+    return removeUndefinedAndNullValues({
+        ...properties,
+        partner_name: PARTNER_NAME,
+    });
+};
+export { getTrackResponse }