iidrak-analytics-react 1.2.4

package/metastreamio/metastreamio.recorder.js

@@ -0,0 +1,157 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+import ViewShot, { captureRef } from "react-native-view-shot";
+import { Platform, Dimensions } from "react-native";
+
+strf();
+
+class MetaStreamIORecorder {
+    constructor({ constants, logger, network, config } = {}) {
+        this.constant = constants;
+        this.logger = logger;
+        this.network = network;
+        this.config = config;
+
+        this.isRecording = false;
+        this.sessionId = null;
+        this.endpoint = null;
+        this.intervalId = null;
+
+        // Default to first endpoint if specific one not provided
+        this.endpoint = config.recordingEndpoint || (this.network.endpoints.length > 0 ? this.network.endpoints[0].replace(/:[0-9]+/, "") + ":8000" : null);
+
+        // Use lower quality by default to save bandwidth
+        this.quality = config.quality || 0.5;
+        this.fps = config.fps || 2; // Frames per second (0.5s interval)
+    }
+
+    setSessionId(id) {
+        this.sessionId = id;
+    }
+
+    async startRecording(viewRef) {
+        if (this.isRecording || !this.sessionId || !this.endpoint) {
+            if (!this.endpoint) this.logger.warn("recorder", "No recording endpoint configured");
+            return;
+        }
+
+        try {
+            this.logger.log("recorder", `Starting session recording for ${this.sessionId} to ${this.endpoint}`);
+
+            // 1. Initialize Session on Python Server
+            // Note: We use a separate fetch here because the payload format is different from standard analytics
+            await fetch(`${this.endpoint}/sessions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    device_info: {
+                        width: Dimensions.get('window').width,
+                        height: Dimensions.get('window').height,
+                        platform: Platform.OS,
+                        sessionId: this.sessionId // Pass our analytics session ID
+                    }
+                })
+            }).then(async res => {
+                if (res.ok) {
+                    const data = await res.json();
+                    // Server might return its own ID, but we want to map them. 
+                    // For simplicity, we assume server respects ours or we track the mapping.
+                    // In this demo, the server generates a timestamp ID. That's fine.
+                    this.recorderSessionId = data.session_id;
+                    this.isRecording = true;
+                    this.startLoop(viewRef);
+                } else {
+                    this.logger.error("recorder", "Failed to start session on recording server");
+                }
+            }).catch(err => {
+                this.logger.error("recorder", "Connection error to recording server: " + err);
+            });
+
+        } catch (err) {
+            this.logger.error("recorder", "Start recording error: " + err);
+        }
+    }
+
+    stopRecording() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        this.isRecording = false;
+        this.logger.log("recorder", "Stopped recording");
+    }
+
+    startLoop(viewRef) {
+        const intervalMs = 1000 / this.fps;
+
+        this.intervalId = setInterval(async () => {
+            if (!viewRef.current) return;
+
+            try {
+                const uri = await captureRef(viewRef, {
+                    format: "jpg",
+                    quality: this.quality,
+                    result: "tmpfile"
+                });
+
+                this.uploadFrame(uri);
+            } catch (e) {
+                // Silent fail on capture error to avoid log spam
+            }
+        }, intervalMs);
+    }
+
+    async uploadFrame(uri) {
+        if (!this.recorderSessionId) return;
+
+        const formData = new FormData();
+        const duration = 1.0 / this.fps;
+        const timestamp = Date.now() / 1000;
+
+        formData.append('timestamp', String(timestamp));
+        formData.append('duration', String(duration));
+        formData.append('file', {
+            uri: uri,
+            type: 'image/jpeg',
+            name: 'screenshot.jpg',
+        });
+
+        try {
+            await fetch(`${this.endpoint}/sessions/${this.recorderSessionId}/screenshot`, {
+                method: 'POST',
+                body: formData,
+                headers: {
+                    'Content-Type': 'multipart/form-data',
+                }
+            });
+        } catch (e) {
+            // Network error, drop frame
+        }
+    }
+
+    // Record interactions (Touch events)
+    async recordInteraction(type, nativeEvent) {
+        if (!this.isRecording || !this.recorderSessionId) return;
+
+        const { pageX, pageY } = nativeEvent;
+        const { width, height } = Dimensions.get('window');
+
+        const event = {
+            type,
+            x: pageX / width,
+            y: pageY / height,
+            timestamp: Date.now() / 1000
+        };
+
+        try {
+            fetch(`${this.endpoint}/sessions/${this.recorderSessionId}/events`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify([event])
+            }).catch(() => { });
+        } catch (e) { }
+    }
+}
+
+export { MetaStreamIORecorder };

package/metastreamio/metastreamio.session.js

@@ -0,0 +1,150 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+import { SessionModel } from "./models/event.session.js";
+import { UtmModel } from "./models/event.session.utm.js";
+
+/*
+ *
+ * Session management
+ *
+ */
+
+class MetaStreamIOSession {
+  constructor({
+    constants,
+    date,
+    environment,
+    logger,
+    network,
+    sessionLength,
+    utility,
+  } = {}) {
+    this.constant = constants;
+    this.date = date;
+    this.environment = environment;
+    this.logger = logger;
+    this.network = network;
+    this.session_length = sessionLength
+      ? sessionLength
+      : this.constant.MetaStreamIO_SessionLengthSeconds;
+    this.session = new SessionModel();
+    this.utility = utility;
+  }
+
+  reset() {
+    this.session = new SessionModel();
+  }
+
+  generateNewSessionId(session_id) {
+    if (session_id) {
+      return session_id;
+    } else {
+      return this.utility.generateRandomId();
+    }
+  }
+
+  setSource(source = null) {
+    this.session.source = source ? source : null;
+    return this.session.source;
+  }
+
+  setUTM({
+    utm_source = null,
+    utm_medium = null,
+    utm_campaign = null,
+    utm_term = null,
+    utm_content = null,
+  } = {}) {
+    this.session.utm = new UtmModel({
+      utm_source: utm_source ? utm_source : null,
+      utm_medium: utm_medium ? utm_medium : null,
+      utm_campaign: utm_campaign ? utm_campaign : null,
+      utm_term: utm_term ? utm_term : null,
+      utm_content: utm_content ? utm_content : null,
+    }).list();
+    return this.session.utm;
+  }
+
+  createNewSession({
+    session_id = null,
+    session_source = null,
+    session_utm = null,
+  } = {}) {
+    let _id, _source, _start_time, _utm;
+
+    try {
+      _id = this.generateNewSessionId(session_id);
+    } catch (err) {
+      this.logger.warn(
+        "session",
+        "<createNewSession> could not generate / set new id: " + err
+      );
+      _id = null;
+    }
+
+    try {
+      _source = session_source ? session_source : null;
+    } catch {
+      source = null;
+    }
+
+    try {
+      _start_time = this.date.getEventTimestamp();
+    } catch {
+      _start_time = null;
+    }
+
+    try {
+      _utm = this.setUTM(session_utm);
+    } catch (err) {
+      this.logger.warn("session", "could not set session UTM: " + err);
+    }
+
+    this.session = new SessionModel({
+      id: _id,
+      source: _source,
+      start_time: _start_time,
+      utm: _utm,
+    });
+  }
+
+  logSession({ last_event_time = null } = {}) {
+    if (last_event_time) {
+      if (!this.checkSessionIsValid(last_event_time)) {
+        this.logger.warn("session", "session expired - starting new session");
+        this.createNewSession();
+      }
+    }
+    return this.utility.copyObject(this.session);
+  }
+
+  checkSessionIsValid(last_event_time) {
+    try {
+      let current_time = this.date.getEventTimestamp();
+      let session_length_seconds = (current_time - last_event_time) / 1e6;
+      this.logger.log(
+        "session",
+        "<checkSessionIsValid> current session length: ",
+        session_length_seconds
+      );
+      if (!last_event_time || session_length_seconds > this.session.length) {
+        return false;
+      } else {
+        return true;
+      }
+    } catch (err) {
+      this.logger.log(
+        "session",
+        "<checkSessionIsValid> problem checking session length: ",
+        err
+      );
+      return false;
+    }
+  }
+}
+
+export { MetaStreamIOSession };

package/metastreamio/metastreamio.user.js

@@ -0,0 +1,79 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+class MetaStreamIOUser {
+  constructor({
+    constants = null,
+    logger = null,
+    id = null,
+    ciam_id = null,
+    email_id = null,
+    country = null,
+  } = {}) {
+    this.constant = constants;
+    this.logger = logger;
+    this.set(id);
+    this.setCountry(country);
+    this.setCiam(ciam_id);
+    this.setEmail(email_id);
+  }
+
+  reset() {
+    this.set();
+    this.setCiam();
+    this.setDeviceToken();
+    this.setEmail();
+  }
+
+  set(id = null) {
+    if (id !== null) {
+      this.id = id;
+    } else {
+      this.id = this.constant.MetaStreamIO_User_Guest;
+    }
+
+    this.logger.log(
+      "user",
+      this.constant.MetaStreamIO_Log_UserIdSet.format(this.id)
+    );
+  }
+
+  setCiam(id = null) {
+    this.ciam_id = id;
+    this.logger.log(
+      "user",
+      this.constant.MetaStreamIO_Log_CIAMIdSet.format(this.ciam_id)
+    );
+  }
+
+  setCountry(country = null) {
+    this.country = country;
+    this.logger.log(
+      "user",
+      this.constant.MetaStreamIO_Log_UserCountrySet.format(this.country)
+    );
+  }
+
+  setDeviceToken(device_token = null) {
+    this.device_token = device_token;
+    this.logger.log(
+      "user",
+      this.constant.MetaStreamIO_Log_PushDeviceTokenSet.format(
+        this.device_token
+      )
+    );
+  }
+
+  setEmail(email = null) {
+    this.email_id = email;
+    this.logger.log(
+      "user",
+      this.constant.MetaStreamIO_Log_EmailIdSet.format(this.email_id)
+    );
+  }
+}
+
+export { MetaStreamIOUser };

package/metastreamio/metastreamio.userproperties.js

@@ -0,0 +1,76 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+import { UserPropertyModel } from "./models/event.userproperty.js";
+
+/*
+ *
+ * Environment class
+ *
+ */
+
+class MetaStreamIOUserProperties {
+  constructor({ constants, logger, stored_user_properties, utility } = {}) {
+    this.constant = constants;
+    this.logger = logger;
+    this.properties = stored_user_properties ? stored_user_properties : {};
+    this.utility = utility;
+  }
+
+  reset() {
+    this.properties = {};
+  }
+
+  delete({ key } = {}) {
+    if (key in this.properties) {
+      delete this.properties[key];
+    }
+    return null;
+  }
+
+  get({ key } = {}) {
+    if (key in this.properties) {
+      return this.properties[key];
+    } else {
+      return null;
+    }
+  }
+
+  set({ key, value } = {}) {
+    let value_type = this.utility.type_to_name(value);
+
+    this.properties[key] = new UserPropertyModel({
+      key: key,
+      value_type: value_type,
+      value: value,
+    });
+
+    this.logger.log(
+      "userproperties",
+      this.constant.MetaStreamIO_Log_UserPropertySet.format(
+        key,
+        JSON.stringify(value),
+        value_type
+      )
+    );
+
+    return this.get({ key: key });
+  }
+
+  list() {
+    let properties = Object.keys(this.properties);
+    let list = [];
+    for (let property of properties) {
+      list.push({
+        key: this.properties[property].key,
+        value: this.properties[property].value_type_value,
+      });
+    }
+    return list;
+  }
+}
+
+export { MetaStreamIOUserProperties };

package/metastreamio/metastreamio.utility.js

@@ -0,0 +1,206 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+/*
+ *
+ * Utilities class
+ *
+ */
+
+class MetaStreamIOUtils {
+  constructor({ constants, date, logger } = {}) {
+    this.date = date;
+    this.logger = logger;
+    this.constant = constants;
+  }
+
+  generateRandomId() {
+    return (
+      String(this.date.getEventTimestamp() * Math.random()) +
+      ":" +
+      String(Math.floor(1000 + (9999 - 1000) * Math.random()))
+    );
+  }
+
+  // Check if input is an integer
+  isInteger(n) {
+    if (n != null) {
+      return Math.ceil(parseFloat(n)) === n;
+    } else {
+      return false;
+    }
+  }
+
+  // Return the type of a given input
+  type_to_name(value) {
+    var type = typeof value;
+    if (type == "number") {
+      if (this.isInteger(value) === true) {
+        type = "integer";
+      } else {
+        type = "float";
+      }
+    }
+    return type;
+  }
+
+  // Make a distinct copy of an object
+  copyObject(input) {
+    try {
+      return JSON.parse(JSON.stringify(input));
+      // return clone;
+    } catch {
+      return {};
+    }
+  }
+
+  // Flatten an object
+  flattenArray(source, delimiter = ".", filter) {
+    var result = {};
+    (function flat(obj, stack) {
+      try {
+        Object.keys(obj).forEach(function (k) {
+          var s = stack.concat([k]);
+          var v = obj[k];
+          if (filter && filter(k, v)) return;
+          if (typeof v === "object") flat(v, s);
+          else result[s.join(delimiter)] = v;
+        });
+      } catch (err) {
+        return {};
+      }
+    })(source, []);
+    return result;
+  }
+
+  // Compare two objects
+  compareArrays({ newArray, oldArray } = {}) {
+    var nK = this.flattenArray(newArray);
+    var oK = this.flattenArray(oldArray);
+    if (Object.keys(nK).length !== Object.keys(oK).length) {
+      return true;
+    }
+    if (nK != null || nK != {}) {
+      if (oK != null || oK != {}) {
+        for (let x in nK) {
+          if (nK[x] !== oK[x]) {
+            return true;
+          }
+        }
+      } else {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Convert event object to a list of objects
+  eventObjToList(input = {}) {
+    var output = [];
+    var iK = Object.keys(input);
+    if (iK.length > 0) {
+      for (let x of iK) {
+        let val = {};
+        val["key"] = x;
+        val["value"] = input[x];
+        output.push(val);
+      }
+    }
+    return output;
+  }
+
+  // Convert cart object to a list of objects with the bundle id as the key for each
+  cartObjToList(input = {}) {
+    var output = [];
+    var iK = Object.keys(input);
+    if (iK.length > 0) {
+      for (let x of iK) {
+        let bundle = {};
+        bundle["bundle_id"] = x;
+        let target = Object.assign({}, bundle, input[x]);
+        output.push(target);
+      }
+    }
+    return output;
+  }
+
+  // Data hygiene: return only input or null
+  validateData(input) {
+    if (input !== "undefined" && input !== null) {
+      return input;
+    } else {
+      return null;
+    }
+  }
+
+  setAppId(id) {
+    if (typeof id !== "undefined" && id.length > 0) {
+      this.logger.log(
+        "project",
+        this.constant.MetaStreamIO_IO_ProjectIdSet.format(id)
+      );
+      return id;
+    } else {
+      this.logger.warn(
+        "project",
+        this.constant.MetaStreamIO_IO_ProjectIdNotSet
+      );
+      return null;
+    }
+  }
+
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  castEventParameterTypes(eventParameters) {
+    try {
+      let castEventParameters = [];
+      eventParameters.forEach((parameter) => {
+        let value_type = this.type_to_name(parameter.value);
+        let temp_param = {};
+        temp_param["key"] = parameter.key;
+        temp_param["value"] = { ["" + value_type]: parameter.value };
+        castEventParameters.push(temp_param);
+      });
+      return castEventParameters;
+    } catch (err) {
+      return [];
+    }
+  }
+
+  async checkBlockingProcess(checkVariable) {
+    return new Promise(async (resolve, reject) => {
+      var max_retries = 5;
+      var retry = 0;
+      while (checkVariable === false && retry < max_retries) {
+        await this.sleep(500);
+        retry++;
+        continue;
+      }
+      if (checkVariable === true) {
+        resolve(checkVariable);
+      } else {
+        reject(Object.keys(checkVariable));
+      }
+    });
+  }
+
+  async makeBlockingProcess(checkVariable, fn, args) {
+    checkVariable = true;
+    let function_call = await fn(args)
+      .then((result) => {
+        return Promise.resolve(result);
+      })
+      .catch((result) => {
+        return Promise.reject(result);
+      });
+    checkVariable = false;
+    return function_call;
+  }
+}
+
+export { MetaStreamIOUtils };

package/metastreamio/models/constructor.app.js

@@ -0,0 +1,24 @@
+export class AppConstructorModel {
+  constructor({
+    id = null,
+    channel = null,
+    environment = null,
+    endpoints = null,
+    headers = null,
+  } = {}) {
+    this.id = id;
+    this.channel = channel;
+    this.environment = environment;
+    this.endpoints = endpoints;
+    this.headers = headers;
+  }
+  json() {
+    return {
+      id: this.id,
+      channel: this.channel,
+      environment: this.environment,
+      endpoints: this.endpoints,
+      headers: this.headers,
+    };
+  }
+}