iidrak-analytics-react 1.2.4

package/metastreamio/metastreamio.date.js

@@ -0,0 +1,41 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+/*
+ *
+ * Date utilities class
+ *
+ */
+
+class MetaStreamIODate {
+  constructor({ logger } = {}) {
+    this.logger = logger;
+  }
+
+  // Generate a UTC timestamp at the time an event occurs
+  getEventTimestamp() {
+    var event_timestamp = new Date().getTime() * 1000;
+    return event_timestamp;
+  }
+
+  // Get the current data
+  getEventDate() {
+    var date = new Date().toISOString().substr(0, 10);
+    return date;
+  }
+
+  // Return the timezone offset of the device
+  getDeviceTimezoneOffset() {
+    const newDateNow = new Date();
+    return (newDateNow.getTimezoneOffset() * 60) / -1;
+  }
+
+  validateDatetime(dt) {
+    return new Date(dt).getTime() > 0;
+  }
+}
+
+export { MetaStreamIODate };

package/metastreamio/metastreamio.environment.js

@@ -0,0 +1,406 @@
+"use strict";
+
+import { strf } from "./string.format.js";
+
+strf();
+
+import DeviceInfo from "react-native-device-info";
+
+import NetInfo from "@react-native-community/netinfo";
+
+// import react native libraries
+import { Dimensions } from "react-native";
+
+// MetaStreamIO models
+import { AppInfoModel } from "./models/event.appinfo.js";
+import { AppPerformanceModel } from "./models/event.appperformance.js";
+import { DeviceModel } from "./models/event.device.js";
+import { NetworkInfoModel } from "./models/event.network.js";
+
+/*
+ *
+ * Environment class
+ *
+ */
+
+class MetaStreamIOEnvironment {
+  constructor({ constants, logger, date, _enum } = {}) {
+    this.constant = constants;
+    this.date = date;
+    this.logger = logger;
+    this.app_info = new AppInfoModel();
+    this.app_performance = new AppPerformanceModel();
+    this.device = new DeviceModel();
+    this.network_info = new NetworkInfoModel();
+  }
+
+  reset() {
+    this.app_info = new AppInfoModel();
+    this.app_performance = new AppPerformanceModel();
+    this.device = new DeviceModel();
+    this.network_info = new NetworkInfoModel();
+  }
+
+  async _getAppInfo() {
+    return await this.logAppInfo()
+      .then((appInfo) => {
+        return Promise.resolve(appInfo);
+      })
+      .catch((err) => {
+        return Promise.reject(err);
+      });
+  }
+
+  getAppInfo() {
+    return this.logAppInfo();
+  }
+
+  async logAppInfo() {
+    let app_id = null;
+    let first_installation_time = null;
+    let installation_id = null;
+    let install_referrer = null;
+    let last_update_time = null;
+    let version = null;
+
+    app_id = DeviceInfo.getBundleId() ? DeviceInfo.getBundleId() : null;
+
+    first_installation_time = await DeviceInfo.getFirstInstallTime()
+      .then((result) => {
+        if (this.date.validateDatetime(result)) {
+          return result;
+        } else {
+          return null;
+        }
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+        return null;
+      });
+
+    installation_id = "deprecated"; // Constants.installationId;
+
+    install_referrer = await DeviceInfo.getInstallReferrer()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+        return null;
+      });
+
+    last_update_time = await DeviceInfo.getLastUpdateTime()
+      .then((result) => {
+        if (this.date.validateDatetime(result)) {
+          return result;
+        } else {
+          return null;
+        }
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+        return null;
+      });
+
+    version = DeviceInfo.getVersion() ? DeviceInfo.getVersion() : null;
+
+    this.app_info = new AppInfoModel({
+      first_installation_time: first_installation_time,
+      id: app_id,
+      installation_id: installation_id,
+      install_referrer: install_referrer,
+      last_update_time: last_update_time,
+      version: version,
+    });
+
+    this.logger.log(
+      this.constant.MetaStreamIO_Logger_Category_Environment,
+      this.constant.MetaStreamIO_Environment_AppInfo.format(
+        JSON.stringify(this.app_info)
+      )
+    );
+
+    return this.app_info.json();
+
+    // return Promise.resolve(this.app_info.json());
+  }
+
+  async getAppPerformance() {
+    return await this.logAppPerformance();
+  }
+
+  async logAppPerformance() {
+    let battery_info, battery_level, battery_low_power_mode, battery_state;
+
+    battery_info = {};
+
+    DeviceInfo.getPowerState()
+      .then((state) => {
+        battery_info.battery_level = state.batteryLevel;
+        battery_info.battery_state = state.batteryState;
+        battery_info.battery_low_power_mode = state.lowPowerMode;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    this.app_performance = new AppPerformanceModel({
+      battery_low_power_mode: battery_low_power_mode,
+      battery_percentage: battery_level,
+      battery_state: battery_state,
+      data_down_kb: 0,
+      data_up_kb: 0,
+    });
+
+    this.logger.log(
+      this.constant.MetaStreamIO_Logger_Category_Environment,
+      this.constant.MetaStreamIO_Environment_AppPerformance.format(
+        JSON.stringify(this.app_performance)
+      )
+    );
+
+    return Promise.resolve(this.app_performance.json());
+  }
+
+  async getDevice() {
+    return await this.logDevice()
+      .then((device) => {
+        return Promise.resolve(device);
+      })
+      .catch((err) => {
+        return Promise.reject(err);
+      });
+  }
+
+  async logDevice() {
+    let brand,
+      device_type,
+      model,
+      operating_system,
+      operating_system_version,
+      pin_or_fingerprint_set,
+      screen_width,
+      screen_height,
+      storage_total,
+      storage_free,
+      supported_architectures,
+      timezone_offset_sec,
+      total_memory,
+      unique_device_id,
+      used_memory;
+
+    brand = await DeviceInfo.getBrand();
+
+    device_type = await DeviceInfo.getDeviceType();
+
+    model = DeviceInfo.getModel();
+
+    operating_system = DeviceInfo.getSystemName();
+
+    operating_system_version = DeviceInfo.getSystemVersion();
+
+    try {
+      screen_height = Math.round(Dimensions.get("window").height);
+    } catch {
+      screen_height = null;
+    }
+
+    try {
+      screen_width = Math.round(Dimensions.get("window").width);
+    } catch {
+      screen_width = null;
+    }
+
+    storage_free = await DeviceInfo.getFreeDiskStorage()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    storage_total = await DeviceInfo.getTotalDiskCapacity()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    supported_architectures = await DeviceInfo.supportedAbis()
+      .then((result) => {
+        return result.join(",");
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    total_memory = await DeviceInfo.getTotalMemory()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    unique_device_id = DeviceInfo.getUniqueId()
+      ? DeviceInfo.getUniqueId()
+      : null;
+
+    used_memory = await DeviceInfo.getUsedMemory()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    try {
+      timezone_offset_sec = this.date.getDeviceTimezoneOffset();
+    } catch {
+      timezone_offset_sec = null;
+    }
+
+    pin_or_fingerprint_set = await DeviceInfo.isPinOrFingerprintSet()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    this.device = new DeviceModel({
+      brand: brand,
+      device_type: device_type,
+      model: model,
+      operating_system: operating_system,
+      operating_system_version: operating_system_version,
+      pin_or_fingerprint_set: pin_or_fingerprint_set,
+      screen_height: screen_height,
+      screen_width: screen_width,
+      storage_free: storage_free,
+      storage_total: storage_total,
+      supported_architectures: supported_architectures,
+      timezone_offset_sec: timezone_offset_sec,
+      total_memory: total_memory,
+      unique_device_id: unique_device_id,
+      used_memory: used_memory,
+    });
+
+    this.logger.log(
+      this.constant.MetaStreamIO_Logger_Category_Environment,
+      this.constant.MetaStreamIO_Environment_Device.format(
+        JSON.stringify(this.device)
+      )
+    );
+
+    return Promise.resolve(this.device.json());
+  }
+
+  async getNetworkInfo() {
+    return await this.logNetworkInfo()
+      .then((networkInfo) => {
+        return Promise.resolve(networkInfo);
+      })
+      .catch((err) => {
+        return Promise.reject(err);
+      });
+  }
+
+  async logNetworkInfo() {
+    let carrier,
+      carrier_iso_country_code,
+      cellular_generation,
+      mobile_country_code,
+      mobile_network_code,
+      network_state_type,
+      net_info;
+
+    carrier = await DeviceInfo.getCarrier()
+      .then((result) => {
+        return result;
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    net_info = await NetInfo.fetch()
+      .then((state) => {
+        return {
+          connection_type: state.type,
+          connection_active: state.isConnected,
+          cellular_generation:
+            state.type === "cellular" ? state.details.cellularGeneration : null,
+        };
+      })
+      .catch((err) => {
+        this.logger.warn(
+          this.constant.MetaStreamIO_Logger_Category_Environment,
+          err
+        );
+      });
+
+    carrier_iso_country_code = null;
+
+    cellular_generation = net_info.cellular_generation;
+
+    mobile_country_code = null;
+
+    mobile_network_code = null;
+
+    network_state_type = net_info.connection_type;
+
+    this.logger.log(
+      this.constant.MetaStreamIO_Logger_Category_Environment,
+      this.constant.MetaStreamIO_Environment_Network.format(
+        JSON.stringify(this.network_info)
+      )
+    );
+
+    this.network_info = new NetworkInfoModel({
+      carrier: carrier,
+      carrier_iso_country_code: carrier_iso_country_code,
+      cellular_generation: cellular_generation,
+      mobile_country_code: mobile_country_code,
+      mobile_network_code: mobile_network_code,
+      network_state_type: network_state_type,
+    });
+
+    return Promise.resolve(this.network_info.json());
+  }
+}
+
+export { MetaStreamIOEnvironment };