iidrak-analytics-react 1.2.4

package/metastreamio/metastreamio.interface.js

@@ -0,0 +1,591 @@
+"use strict";
+
+// Global string format function, similar to Python
+
+import { strf } from "./string.format.js";
+
+strf();
+
+// MetaStreamIO modules
+import { MetaStreamIOCart } from "./metastreamio.cart.js";
+import { MetaStreamIOConstants } from "./metastreamio.constants.js";
+import { MetaStreamIODate } from "./metastreamio.date.js";
+import { MetaStreamIOEnvironment } from "./metastreamio.environment.js";
+import { MetaStreamIOLogger } from "./metastreamio.logger.js";
+import { MetaStreamIOAccountData } from "./metastreamio.account.js";
+import { MetaStreamIONetwork } from "./metastreamio.network.js";
+import { MetaStreamIOSession } from "./metastreamio.session.js";
+import { MetaStreamIOUser } from "./metastreamio.user.js";
+import { MetaStreamIOUserProperties } from "./metastreamio.userproperties.js";
+import { MetaStreamIOUtils } from "./metastreamio.utility.js";
+import { Queue } from "./metastreamio.queue.js";
+import { MetaStreamIORecorder } from "./metastreamio.recorder.js";
+
+
+// MetaStreamIO models
+import { CartModel } from "./models/event.cart.js";
+import { CartItemModel } from "./models/event.cartitem.js";
+import { EventModel } from "./models/event.event.js";
+import { EventParametersModel } from "./models/event.parameters.js";
+import { EventParameterModel } from "./models/event.parameter.js";
+import { AppConstructorModel } from "./models/constructor.app.js";
+import { ConfigConstructorModel } from "./models/constructor.config.js";
+import { UserConstructorModel } from "./models/constructor.user.js";
+
+/*
+ *
+ * Main analytics interface class
+ *
+ */
+
+class MetaStreamIO {
+  constructor({ app = {}, config = {}, user = {} } = {}) {
+    this.appConfig = this.validateConstructor(app, new AppConstructorModel());
+    this.config = this.validateConstructor(
+      config,
+      new ConfigConstructorModel()
+    );
+    this.userConfig = this.validateConstructor(
+      user,
+      new UserConstructorModel()
+    );
+    this.constant = new MetaStreamIOConstants();
+    this.date = new MetaStreamIODate();
+    this.logger = new MetaStreamIOLogger({
+      constants: this.constant,
+      logPrefix: this.constant.MetaStreamIO_Logger_Prefix,
+      loggingEnabled: this.config.logging,
+      loggingLevel: this.config.loggingLevel,
+      loggingCategories: this.config.loggingCategories,
+      loggingAlwaysError: this.config.loggingAlwaysError,
+      loggingAlwaysWarn: this.config.loggingAlwaysWarn,
+    });
+    this.utility = new MetaStreamIOUtils({
+      constants: this.constant,
+      date: this.date,
+      logger: this.logger,
+    });
+    this.cart = new MetaStreamIOCart({
+      constants: this.constant,
+      date: this.date,
+      logger: this.logger,
+      utility: this.utility,
+    });
+    this.environment = new MetaStreamIOEnvironment({
+      constants: this.constant,
+      logger: this.logger,
+      date: this.date,
+    });
+    this.network = new MetaStreamIONetwork({
+      constants: this.constant,
+      logger: this.logger,
+      silentMode: this.config.silentMode,
+      endpoints: this.appConfig.endpoints,
+      headers: this.appConfig.headers,
+    });
+    this.account = new MetaStreamIOAccountData({
+      constants: this.constant,
+      logger: this.logger,
+      utility: this.utility,
+    });
+    this.session = new MetaStreamIOSession({
+      constants: this.constant,
+      date: this.date,
+      environment: this.environment,
+      logger: this.logger,
+      network: this.network,
+      sessionLength: this.config.sessionLength,
+      utility: this.utility,
+    });
+    this.user = new MetaStreamIOUser({
+      constants: this.constant,
+      logger: this.logger,
+    });
+    this.userproperties = new MetaStreamIOUserProperties({
+      constants: this.constant,
+      logger: this.logger,
+      utility: this.utility,
+    });
+
+    this.queue = new Queue();
+
+    this.recorder = new MetaStreamIORecorder({
+      constants: this.constant,
+      logger: this.logger,
+      network: this.network,
+      config: this.config,
+    });
+
+    // Init global variables
+    this.previous = {};
+    this.app_id = this.utility.setAppId(this.appConfig.id);
+    this.app_environment = this.appConfig.environment;
+    this.channel = this.appConfig.channel;
+
+    if (this.userConfig.guestMode === true) {
+      this.start_session({
+        user_id: this.userConfig.user_id,
+        ciam_id: this.userConfig.ciam_id,
+        email_id: this.userConfig.email_id,
+        country: this.userConfig.country,
+        cart_id: this.userConfig.cart_id,
+      });
+    }
+  }
+
+  /*
+   * Session
+   */
+
+  start_session({
+    user_id = null,
+    ciam_id = null,
+    email_id = null,
+    country = null,
+    cart_id = null,
+    reset = false,
+  } = {}) {
+    let errors = [];
+    this.logger.log(
+      "session",
+      `start session :: user: <${user_id}> cart: <${cart_id}>`
+    );
+
+    if (reset) {
+      this.reset();
+    }
+
+    try {
+      this.user.set(user_id);
+    } catch (err) {
+      errors.push("user_id");
+      this.logger.log("user", "could not set user id :: " + err);
+    }
+
+    try {
+      this.user.setCiam(ciam_id);
+    } catch (err) {
+      errors.push("ciam_id");
+      this.logger.log("user", "could not set ciam id :: " + err);
+    }
+
+    try {
+      this.user.setEmail(email_id);
+    } catch (err) {
+      errors.push("email_id");
+      this.logger.log("user", "could not set email id :: " + err);
+    }
+
+    try {
+      this.user.setCountry(country);
+    } catch (err) {
+      errors.push("country");
+      this.logger.log("user", "could not set user country :: " + err);
+    }
+
+    this.cart.clear(cart_id);
+
+    try {
+      if (!this.session.session.id) {
+        const newSessionId = this.utility.generateRandomId(); // Assuming session uses something like this
+        this.session.createNewSession({
+          session_id: newSessionId,
+          session_source: null,
+          session_utm: {},
+        });
+        // Update recorder session ID
+        if (this.recorder) this.recorder.setSessionId(this.session.session.id);
+      }
+    } catch (err) {
+      errors.push("session");
+      this.logger.log("session", "could not create new session: " + err);
+    }
+    return errors;
+  }
+
+  reset() {
+    this.account.reset();
+    this.cart.reset();
+    this.environment.reset();
+    this.network.reset();
+    this.session.reset();
+    this.user.reset();
+    this.userproperties.reset();
+    if (this.recorder) this.recorder.stopRecording();
+  }
+
+  async validateSession() {
+    var errors = [];
+
+    this.logger.log("session", "validateSession() validating session");
+    if (!this.session.session.id || !this.cart.cart.id) {
+      try {
+        let _start_session = this.start_session();
+        if (_start_session.length === 0) {
+          this.logger.log("session", "validateSession() started new session");
+        } else {
+          errors.push(_start_session);
+        }
+      } catch (err) {
+        this.logger.log(
+          "session",
+          "validateSession() error starting new session: " + err
+        );
+        errors.push("validateSession() error starting new session: " + err);
+      }
+    } else {
+      this.logger.log(
+        "session",
+        `validateSession() did not start new session session <${this.session.session.id}> cart <${this.cart.cart.id}>`
+      );
+    }
+
+    if (!this.network.endpoint) {
+      await this.network
+        .testConnection()
+        .then((response) => {
+          this.logger.log(
+            "session",
+            `validateSession() testConnection returned: ${response}`
+          );
+        })
+        .catch((err) => {
+          this.logger.log(
+            "session",
+            `validateSession() testConnection error: ${err}`
+          );
+          errors.push("validateSession() network issue");
+        });
+    }
+
+    if (errors.length === 0) {
+      return Promise.resolve("success");
+    } else {
+      return Promise.reject(errors);
+    }
+  }
+
+  /*
+   * Settings
+   */
+
+  setAllowTrackCategories(categories = []) {
+    if (Array.isArray(categories) === true) {
+      this.config.allowTrackCategories = categories;
+    }
+  }
+
+  /*
+   * Track events
+   */
+
+  checkEventName(eventName) {
+    try {
+      if (typeof eventName !== "undefined" && eventName.length > 0) {
+        return true;
+      } else {
+        return false;
+      }
+    } catch (err) {
+      this.logger.log(
+        "event",
+        `checkEventName() error checking event name: ${err}`
+      );
+      return false;
+    }
+  }
+
+  testAllowedTrackCategory(category) {
+    if (Array.isArray(this.config.allowTrackCategories)) {
+      return this.config.allowTrackCategories.length === 0
+        ? true
+        : this.config.allowTrackCategories.includes(category);
+    } else {
+      return true;
+    }
+  }
+
+  trackEvent({
+    eventName,
+    eventParameters,
+    sendOnce = this.constant.MetaStreamIO_SendOnceDefault,
+    temporaryCart = false,
+    transactionId = null,
+    category = null,
+  } = {}) {
+    if (category !== null) {
+      if (this.testAllowedTrackCategory(category) === false) {
+        this.logger.warn(
+          "event",
+          `not allowed to track this category: ${category}`
+        );
+        return;
+      }
+    }
+    if (this.checkEventName(eventName) === true) {
+      let cart = temporaryCart.items
+        ? this.utility.copyObject(temporaryCart.list())
+        : this.utility.copyObject(this.cart.cart.list());
+      let lastCart = this.utility.copyObject(this.cart.lastCart);
+      let lastEventName = this.previous.event_name;
+      let tempEventParameters =
+        this.utility.castEventParameterTypes(eventParameters);
+      let lastEventParameters = this.utility.copyObject(
+        this.previous.event_params
+      );
+      let userProperties = this.utility.copyObject(this.userproperties.list());
+      let lastUserProperties = this.utility.copyObject(
+        this.previous.user_properties
+      );
+      let client_event_date = this.date.getEventDate();
+      let client_event_timestamp = this.date.getEventTimestamp();
+
+      // Get difference between previous event object and current
+      var eventParamDiff = this.utility.compareArrays({
+        newArray: tempEventParameters,
+        oldArray: lastEventParameters ? lastEventParameters : {},
+      });
+      var userPropertyDiff = this.utility.compareArrays({
+        newArray: userProperties,
+        oldArray: lastUserProperties ? lastUserProperties : {},
+      });
+      var cartDiff = this.utility.compareArrays({
+        newArray: cart,
+        oldArray: lastCart ? lastCart : {},
+      });
+
+      if (
+        sendOnce === true &&
+        eventName === lastEventName &&
+        eventParamDiff === false &&
+        userPropertyDiff === false &&
+        cartDiff === false
+      ) {
+        this.logger.log("event", this.constant.MetaStreamIO_Log_SendOnce);
+      } else {
+        let e = new EventModel({
+          account_balances: this.utility.copyObject(
+            this.account.account.list()
+          ),
+          account_type: this.account.account.type,
+          app: this.app_id,
+          app_environment: this.app_environment,
+          app_info: null,
+          app_performance: null,
+          cart: cart,
+          cart_id: temporaryCart ? temporaryCart.id : this.cart.cart.id,
+          channel: this.channel,
+          ciam_id: this.user.ciam_id,
+          client_event_date: client_event_date,
+          client_event_timestamp: client_event_timestamp,
+          device: null,
+          device_token: this.user.device_token,
+          email_id: this.user.email_id,
+          event_name: eventName,
+          event_params: tempEventParameters,
+          network: null,
+          session: this.utility.copyObject(
+            this.session.logSession(this.previous.event_time)
+          ),
+          transaction_id: transactionId,
+          user_id: this.user.id,
+          user_country: this.user.country,
+          user_properties: this.utility.copyObject(this.userproperties.list()),
+        });
+
+        this.storeEventMeta({
+          eventTimestamp: client_event_timestamp,
+          eventName: eventName,
+          eventParameters: this.utility.copyObject(tempEventParameters),
+        });
+        try {
+          this.queue.enqueue(e);
+          this.runQueue().catch((err) => {
+            this.logger.log("event", `could no run the queue: ${err}`);
+          });
+        } catch (err) {
+          this.logger.log("event", `trackEvent() QUEUE ${err}`);
+        }
+      }
+    }
+
+    // CLEAN UP
+    this.handleEventRules(eventName);
+  }
+
+  // Bypass any active shopping cart and submit a quick buy event
+
+  trackQuickBuy({
+    eventName,
+    eventParameters,
+    temporaryCart = null,
+    transactionId = null,
+  } = {}) {
+    var item = {};
+
+    if (temporaryCart && typeof temporaryCart === "object") {
+      let _tCart = new CartModel({
+        id: this.utility.generateRandomId(),
+        items: {
+          [temporaryCart.id]: this.validateConstructor(
+            temporaryCart,
+            new CartItemModel()
+          ),
+        },
+      });
+      this.trackEvent({
+        eventName: eventName,
+        eventParameters: eventParameters,
+        sendOnce: true,
+        temporaryCart: _tCart,
+        transactionId: transactionId,
+      });
+    }
+  }
+
+  async post_event(event_data) {
+    if (event_data) {
+      var status = await this.network
+        .postData({ data: event_data })
+        .then((data) => {
+          let _data = JSON.stringify(data);
+          this.logger.log(
+            "network",
+            this.constant.MetaStreamIO_Network_PostDataReturn.format(_data)
+          );
+          if (data.status == 200) {
+            this.logger.log(
+              "event",
+              this.constant.MetaStreamIO_Log_EventTracked.format(
+                event_data.event.event_name
+              )
+            );
+            return Promise.resolve(event_data);
+          } else if (data.status == 1) {
+            this.logger.warn(
+              "network",
+              this.constant.MetaStreamIO_Network_SilentMode
+            );
+            return Promise.resolve(event_data);
+          } else {
+            this.logger.error(
+              "event",
+              this.constant.MetaStreamIO_Log_EventTrackFailed.format(_data)
+            );
+            this.logger.warn(
+              "network",
+              this.constant.MetaStreamIO_Network_PostDataReturn.format(_data)
+            );
+            return Promise.reject(_data);
+          }
+        })
+        .catch((err) => {
+          this.logger.error("event", "<post_event> could not post: " + err);
+          return Promise.reject(err);
+        });
+      return status;
+    } else {
+      this.logger.error("event", "<post_event> event_data is undefined");
+    }
+  }
+
+  async runQueue() {
+    return this.queue.run(
+      async function (event) {
+        // Enrich
+        event.app_info = await this.environment.logAppInfo().catch(() => null);
+        event.app_performance = await this.environment
+          .logAppPerformance()
+          .catch(() => null);
+        event.device = await this.environment.logDevice().catch(() => null);
+        event.network = await this.environment
+          .logNetworkInfo()
+          .catch(() => null);
+
+        let response = await this.post_event(event.json())
+          .then((res) => {
+            this.logger.log(
+              "event",
+              "<runQueue> event processed, dequeued: " +
+              res["event"]["event_name"] +
+              " " +
+              res["event"]["session"]["id"]
+            );
+            return Promise.resolve();
+          })
+          .catch((err) => {
+            this.logger.error(
+              "event",
+              "<runQueue> this.post_event failed: " + err
+            );
+            this.logger.warn(
+              "event",
+              "could not post event, enqueueing again: " + err
+            );
+            try {
+              this.queue.enqueue(event);
+            } catch (err) {
+              this.logger.error(
+                "event",
+                "<runQueue> could not enqueue event: " + err
+              );
+            }
+            return Promise.reject(err);
+          });
+      }.bind(this)
+    );
+  }
+
+  async storeEventMeta({ eventTimestamp, eventName, eventParameters } = {}) {
+    this.previous.event_time = eventTimestamp;
+    this.previous.event_name = eventName;
+    this.previous.event_params = eventParameters;
+    this.previous.user_properties = this.utility.copyObject(
+      this.userproperties.properties
+    );
+    this.cart.lastCart = this.utility.copyObject(this.cart.cart.list());
+  }
+
+  handleEventRules(eventName) {
+    if (eventName === "purchase") {
+      this.handlePurchaseEvent();
+    }
+
+    if (eventName === "logout") {
+      this.logger.log("session"), "destroying session";
+      this.start_session({ reset: true });
+    }
+  }
+
+  handlePurchaseEvent() {
+    this.cart.clear();
+  }
+
+  validateConstructor(config = null, constructor = null) {
+    /* called before this.logger exists */
+    if (
+      typeof config === "object" &&
+      config !== null &&
+      typeof constructor === "object" &&
+      constructor !== null
+    ) {
+      let keys = Object.keys(constructor);
+      for (let _k in keys) {
+        if (keys[_k] in constructor) {
+          constructor[keys[_k]] = this.validateParameter(keys[_k], config);
+        }
+      }
+    }
+    return constructor;
+  }
+
+  validateParameter(key, config) {
+    if (key in config) {
+      return config[key];
+    } else {
+      return null;
+    }
+  }
+}
+
+export default MetaStreamIO;