@magicpixel/rn-mp-client-sdk 0.2.0

package/src/processors/trans-function.processor.ts

@@ -0,0 +1,85 @@
+/**
+ * Process all the data elements at once, or if a set of keys are specified, processes only
+ * those keys and updates the dataElements object in global-fns file
+ * @param dataElements
+ * @param sdkTransFunctions
+ * @param optTfnKeys
+ */
+import type { MapLike } from '../common/app-types';
+import type { ClientSdkTfnItem } from '../models/mp-client-sdk';
+import { DataStore } from '../common/data-store';
+import { Logger } from '../common/logger';
+import { Utils } from '../common/utils';
+import { Reporter } from '../common/reporter';
+
+export class TransFunctionProcessor {
+  static processTransformationFunctions(
+    dataElements: MapLike<any>,
+    sdkTransFunctions: MapLike<ClientSdkTfnItem>,
+    optTfnKeys?: string[]
+  ): MapLike<any> {
+    const tfn = DataStore.getTransFunctions();
+    const tfnKeys =
+      optTfnKeys && optTfnKeys.length > 0
+        ? optTfnKeys
+        : Object.keys(sdkTransFunctions);
+    try {
+      for (const key of tfnKeys) {
+        try {
+          const tfnItem = sdkTransFunctions[key];
+          /**
+           * How to process transformation functions
+           * 1) Find all the data elements in the resource params of trans function
+           * 2) make them into an object (key value) where key is the resourceKey and value is the value of data elements
+           * 3) Invoke the tfn and get the value and store it against the tfn key
+           */
+
+          if (tfnItem) {
+            if (tfnItem.rParams) {
+              const tfnFnInput: any = {};
+              for (const paramKey of Object.keys(tfnItem.rParams)) {
+                // tfn can have only data elements as of now.
+                const rParam = tfnItem.rParams[paramKey];
+                const deId = rParam?.de;
+                if (deId) {
+                  let paramValue = dataElements[deId] || '';
+                  if (rParam.rqd && !paramValue) {
+                    Logger.logDbg(
+                      `Value required for: ${paramKey}, in transformation function. But not found`
+                    );
+                    break;
+                  }
+                  if (rParam.tf) {
+                    paramValue = Utils.applyTransformationResourceParam(
+                      paramValue,
+                      rParam.tf
+                    );
+                  }
+                  tfnFnInput[paramKey] = paramValue;
+                }
+              }
+              // invoke the function and get the value
+              tfn[key] = tfnItem.fn(tfnFnInput);
+            }
+          } else {
+            tfn[key] = '';
+          }
+        } catch (err) {
+          Logger.logError(
+            'Error processing transformation function: ',
+            key,
+            ' with error: ',
+            err
+          );
+          // TODO: Report as metric to client
+        }
+      }
+    } catch (err) {
+      Logger.logError('Error processing transformation functions: ', err);
+      Reporter.reportError('m::processTransformationFunctions', err);
+    }
+
+    DataStore.setTransFunctions(tfn);
+    return tfn;
+  }
+}

package/src/processors/visit-id.processor.ts

@@ -0,0 +1,164 @@
+import { Logger } from '../common/logger';
+import { DataStore } from '../common/data-store';
+import { Constants } from '../common/constants';
+import { Reporter } from '../common/reporter';
+import { NetworkService } from '../common/network-service';
+import type { VisitInfo, VisitorInfo } from '../common/app-types';
+import { Utils } from '../common/utils';
+import { EventBus } from '../common/event-bus';
+
+export class VisitIdProcessor {
+  static async init(): Promise<void> {
+    await this.initIdlEventListener();
+    await this.initDebugId();
+    await this.setOrResetVisitorId();
+    await this.setOrResetVisitInfo();
+  }
+
+  static async initIdlEventListener(): Promise<void> {
+    EventBus.on(
+      'mp_idl_app_event',
+      (channelName: string, eventPayload: Record<string, string>) => {
+        try {
+          if (!channelName || !eventPayload) {
+            Logger.logError(
+              'Both event name and event payload is mandatory for processing idl events'
+            );
+            return;
+          }
+
+          const eventName = eventPayload.client_ev_name;
+          const attrInfoPayload: any = eventPayload.client_ev_payload ?? {};
+          const deepPayload: any = attrInfoPayload?.payload ?? {};
+
+          // is_entry, app_type,
+          try {
+            deepPayload['org_id'] = eventPayload?.org_id;
+            deepPayload['event_id'] = eventPayload?.event_id;
+            deepPayload['event_ts'] = eventPayload?.event_ts;
+          } catch (e) {
+            Logger.logError('Error enhancing internal attr payload');
+          }
+
+          const attrPayload: any = {
+            pu: attrInfoPayload?.page_url,
+            ru: attrInfoPayload?.campaign_ref,
+            pt: attrInfoPayload?.page_title,
+            en: attrInfoPayload.event_name,
+            cid: attrInfoPayload?.campaign_id,
+            rs: attrInfoPayload?.report_suite,
+            v: attrInfoPayload?.client_sdk_version,
+            vidl: attrInfoPayload?.idl_version,
+            ev: attrInfoPayload?.event_val,
+            ep: deepPayload,
+            at: attrInfoPayload?.app_type,
+            evId: attrInfoPayload?.event_id,
+            evTs: attrInfoPayload?.event_ts,
+            orgId: attrInfoPayload?.org_id,
+            _mp_vid: DataStore.visitInfoToString(),
+            _lmid: DataStore.getMpId(),
+            _ldid: DataStore.getDeviceId(),
+            _mpidl: JSON.stringify(DataStore.getVisitorInfoAsString()),
+            is_entry: attrInfoPayload.is_entry ?? 0,
+            app_type: attrInfoPayload.app_type,
+          };
+
+          if (eventName === 'al') {
+            attrPayload.pid = eventPayload?.profile_id;
+          }
+
+          Reporter.postAttrInfo(attrPayload);
+        } catch (err) {
+          Logger.logError('Error processing idl event: ', err);
+        }
+      }
+    );
+  }
+
+  static async initDebugId(): Promise<void> {
+    try {
+      let debugId = await DataStore.getDataFromStorage<string>(
+        Constants.KEY_MP_DEBUG_ID
+      );
+      if (!debugId) {
+        debugId = Utils.getUniqueID();
+      }
+      await DataStore.storeData(Constants.KEY_MP_DEBUG_ID, debugId);
+      DataStore.setDebugId(debugId);
+    } catch (err) {
+      Logger.logError('Error initializing debug id.', err);
+    }
+  }
+
+  static async setOrResetVisitInfo(): Promise<void> {
+    try {
+      const visitInfo: VisitInfo = await DataStore.getDataFromStorage(
+        Constants.KEY_MP_IDL_VISIT_ID_INFO
+      );
+
+      if (!visitInfo) {
+        // may be first time visit, setup a new visit info object and return
+        const newVisitInfo: VisitInfo = {
+          visitId: Utils.getUniqueID(),
+          visitCt: 1,
+          visitDepth: 1,
+          visitTs: Date.now(),
+          visitVer: 1,
+        };
+        DataStore.setVisitInfo(newVisitInfo);
+        await DataStore.storeData(
+          Constants.KEY_MP_IDL_VISIT_ID_INFO,
+          newVisitInfo
+        );
+      } else {
+        // reset visit id anyway, but retain the visitCt and depth setting
+        visitInfo.visitId = Utils.getUniqueID();
+        visitInfo.visitCt = visitInfo.visitCt + 1;
+        visitInfo.visitDepth = 1;
+        visitInfo.visitTs = Date.now();
+        visitInfo.visitVer = 1;
+        DataStore.setVisitInfo(visitInfo);
+        await DataStore.storeData(
+          Constants.KEY_MP_IDL_VISIT_ID_INFO,
+          visitInfo
+        );
+      }
+    } catch (err) {
+      Logger.logError(err);
+      DataStore.setVisitInfo(null);
+      Reporter.reportError('setOrResetVisitInfo', err);
+    }
+  }
+
+  static async setOrResetVisitorId(): Promise<void> {
+    try {
+      const visitorInfoData: VisitorInfo = await DataStore.getDataFromStorage(
+        Constants.KEY_MP_IDL_VISITOR_ID_INFO
+      );
+
+      if (!visitorInfoData) {
+        Logger.logDbg('VisitorInfo not found. Refreshing from server');
+        // get a new visit id and device id from server and store it in storage
+        const apiVisitInfo = await NetworkService.fetchIdlInfo(
+          DataStore.getIdlUrl()
+        );
+        if (!apiVisitInfo) {
+          return;
+        } else {
+          DataStore.setVisitorInfo(apiVisitInfo);
+          // store to db as well
+          await DataStore.storeData(
+            Constants.KEY_MP_IDL_VISITOR_ID_INFO,
+            apiVisitInfo
+          );
+        }
+      } else {
+        DataStore.setVisitorInfo(visitorInfoData);
+      }
+    } catch (err) {
+      Logger.logError(err);
+      DataStore.setVisitorInfo(null);
+      Reporter.reportError('setOrResetVisitorId', err);
+    }
+  }
+}