@mhubcloud/tms_core 1.7.6 → 2.0.0-beta.0

package/src/publishers/cj.ts

@@ -0,0 +1,67 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+interface CjData {
+  cjevent?: unknown;
+  [x: string]: unknown;
+}
+
+export const cj: PlatformPublisher = {
+  source: 'CJAffiliate',
+  /**
+   * Publishes data to CJ
+   * @param log Azure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (!(data as CjData).cjevent) {
+      utils.log(log, 1, `CJ - ${event} - skipped because CJEVENT is missing`);
+      // ? Tady se returnoval false, ale nemyslim, ze to neco pouzivalo
+    } else {
+      if (typeof config.cid === 'string' && typeof config.type === 'string') {
+        const cjData = utils.removeUndefined(data) as TypeSafeObject;
+        let query = '?cid=' + encodeURI(config.cid);
+        query += '&type=' + encodeURI(config.type);
+        for (const property in data) {
+          if (
+            Object.prototype.hasOwnProperty.call(cjData, property) &&
+            cjData[property] !== undefined
+          ) {
+            query +=
+              '&' +
+              encodeURI(property) +
+              '=' +
+              encodeURI(
+                cjData[property] === null
+                  ? ''
+                  : // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
+                    (cjData[property]?.toString() as string),
+              );
+          }
+        }
+        const baseUrl = 'https://www.kdukvh.com/u';
+
+        const requestOptions: PlatformRequestOptions = {
+          method: 'GET',
+        };
+
+        await utils.handlePlatformRequest({
+          source: this.source,
+          baseUrl,
+          query,
+          requestOptions,
+          event,
+          logger: log,
+        });
+      } else {
+        throw new Error('Invalid config for platform ' + this.source);
+      }
+    }
+  },
+};

package/src/publishers/facebook.ts

@@ -0,0 +1,49 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+
+export const facebook: PlatformPublisher = {
+  source: 'Faceboook',
+  /**
+   *Publishes data to Facebook
+   * @param log Azure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (
+      typeof config.id === 'string' &&
+      typeof config.access_token === 'string'
+    ) {
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        body: JSON.stringify({ data: [utils.removeUndefined(data)] }),
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'Content-Type': 'application/json',
+        },
+      };
+
+      // https://graph.facebook.com/v11.0/<id>/events
+      const baseUrl = `https://graph.facebook.com/v11.0/${encodeURIComponent(
+        config.id,
+      )}/events`;
+
+      const query = `?access_token=${encodeURI(config.access_token)}`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/publishers/googleAnalytics4.ts

@@ -0,0 +1,60 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+export const googleAnalytics4: PlatformPublisher = {
+  source: 'GoogleAnalytics4',
+  /**
+   * Publishes data to Google Analytics
+   * @param log zure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (config.trackingId) {
+      const ga4Data = utils.removeUndefined(data) as TypeSafeObject;
+      ga4Data.v = 2;
+      ga4Data.seg = 1;
+      ga4Data.gcs = 111;
+      ga4Data.tid = config.trackingId;
+
+      let payload = '';
+
+      for (const property in ga4Data) {
+        if (Object.prototype.hasOwnProperty.call(ga4Data, property)) {
+          if (payload) {
+            payload += '&';
+          }
+          payload += encodeURI(property) + '=' + encodeURI(ga4Data[property]);
+        }
+      }
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'User-Agent': 'mHub Cloud',
+        },
+      };
+
+      const baseUrl = 'https://www.google-analytics.com/g/collect';
+
+      const query = `?${payload}`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/publishers/piano.ts

@@ -0,0 +1,71 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+
+interface Aux {
+  visitorId: string;
+  ref: string;
+  userAgent?: string;
+  referer?: string;
+  forwardedFor?: string;
+}
+
+interface PianoData {
+  aux: Aux;
+}
+
+export const piano: PlatformPublisher = {
+  source: 'Piano',
+  /**
+   * Publishes data to Piano
+   * @param log zure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (
+      typeof config.siteId === 'string' &&
+      typeof config.collectionDomain === 'string'
+    ) {
+      const pianoData = utils.removeUndefined(data) as PianoData;
+      let query = '';
+      // https://developers.atinternet-solutions.com/piano-analytics-tagging-en/event-tagging-piano-analytics-en/events-pattern-en/#post-request_5
+      // https://<collection-domain>/<path>?s=<site-id>&idclient=<visitor-id>&ref=<previous-url>
+      query = '?s=' + encodeURI(config.siteId);
+      query += '&idclient=' + encodeURI(pianoData.aux.visitorId);
+      query += '&ref=' + encodeURI(pianoData.aux.ref);
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+      };
+
+      requestOptions.headers = {};
+
+      if (pianoData.aux.userAgent) {
+        requestOptions.headers['User-Agent'] = pianoData.aux.userAgent;
+      }
+      if (pianoData.aux.referer) {
+        requestOptions.headers.Referer = pianoData.aux.referer;
+      }
+      if (pianoData.aux.forwardedFor) {
+        requestOptions.headers['X-Forwarded-For'] = pianoData.aux.forwardedFor;
+      }
+
+      const baseUrl = `https://${config.collectionDomain}/`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/publishers/universalAnalytics.ts

@@ -0,0 +1,63 @@
+import * as utils from './../utils/utils';
+import {
+  PlatformPublisher,
+  PlatformRequestOptions,
+} from '../types/PlatformPublisher';
+import { TypeSafeObject } from '../types/UtilTypes';
+
+export const universalAnalytics: PlatformPublisher = {
+  source: 'UniversalAnalytics',
+  /**
+   * Publishes data to UniversalAnalytics
+   * @param log zure Function context.log
+   * @param config Publisher configuration
+   * @param data Data in publisher-friendly format to be published
+   * @param event Event for which the function is triggered
+   */
+  async publish(log, config, data, event) {
+    if (config.trackingId) {
+      const uaData = utils.removeUndefined(data) as TypeSafeObject;
+      uaData.v = 1;
+      uaData.tid = config.trackingId;
+
+      let payload = '';
+
+      for (const property in uaData) {
+        if (Object.prototype.hasOwnProperty.call(uaData, property)) {
+          if (payload) {
+            payload += '&';
+          }
+          if (uaData[property]) {
+            payload +=
+              encodeURI(property) + '=' + encodeURI(uaData[property] ?? '');
+          }
+        }
+      }
+
+      const requestOptions: PlatformRequestOptions = {
+        method: 'POST',
+        body: payload,
+        headers: {
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'Content-Type': 'application/x-www-form-urlencoded',
+          // eslint-disable-next-line @typescript-eslint/naming-convention
+          'User-Agent': 'mHub Cloud',
+        },
+      };
+      const baseUrl = 'https://www.google-analytics.com/collect';
+
+      const query = `?${payload}`;
+
+      await utils.handlePlatformRequest({
+        source: this.source,
+        baseUrl,
+        query,
+        requestOptions,
+        event,
+        logger: log,
+      });
+    } else {
+      throw new Error('Invalid config for platform ' + this.source);
+    }
+  },
+};

package/src/types/EventHubMessage.ts

@@ -0,0 +1,8 @@
+export interface EventHubMessage {
+  enqueuedAt: number;
+  event: {
+    code: string;
+    name?: string;
+  };
+  [x: string]: unknown;
+}

package/src/types/EventPublisher.ts

@@ -0,0 +1,9 @@
+import { EventHubMessage } from './EventHubMessage';
+
+export interface EventPublisherBaseClass {
+  config: Record<string, unknown>;
+}
+
+export interface EventPublisher extends EventPublisherBaseClass {
+  map: (data: EventHubMessage) => Promise<Record<string, unknown>>;
+}

package/src/types/PlatformPublisher.ts

@@ -0,0 +1,19 @@
+import { HttpMethod, Logger } from '@azure/functions';
+import { BodyInit } from 'node-fetch';
+import { TypeSafeObject } from './UtilTypes';
+
+export interface PlatformPublisher {
+  source: string;
+  publish: (
+    log: Logger,
+    config: TypeSafeObject,
+    data: TypeSafeObject | unknown[],
+    event: string,
+  ) => Promise<void>;
+}
+
+export interface PlatformRequestOptions {
+  method: HttpMethod | undefined;
+  body?: BodyInit | undefined;
+  headers?: Record<string, string>;
+}

package/src/types/UtilTypes.ts

@@ -0,0 +1 @@
+export type TypeSafeObject = Record<string, unknown>;

package/src/types/global.d.ts

@@ -0,0 +1,3 @@
+declare namespace globalThis {
+  function it(): unknown;
+}