@magicpixel/rn-mp-client-sdk 0.2.0

package/src/processors/qc.processor.ts

@@ -0,0 +1,115 @@
+import { DataStore } from '../common/data-store';
+import { Logger } from '../common/logger';
+import { Utils } from '../common/utils';
+import type { ClientSdkQcItem } from '../models/mp-client-sdk';
+import { Constants } from '../common/constants';
+import { Reporter } from '../common/reporter';
+
+export class QcProcessor {
+  static processQc(
+    sdkQc: ClientSdkQcItem[],
+    eventName: string,
+    evtId: string
+  ): string[] {
+    const validQcList: string[] = [];
+    const validQcInfo: Array<{ nm: string; id: string; st: boolean }> = [];
+    try {
+      Logger.logDbg('Processing qc lists for eventId:: ', evtId);
+      for (const qc of sdkQc) {
+        let notMatching = true;
+        Logger.logDbg('Processing QC: ', qc.nm);
+
+        for (const qcCondition of qc.c) {
+          let deVal: string | number | boolean;
+
+          if (
+            qcCondition.param === Constants.CUST_EVT ||
+            qcCondition.param === Constants.MP_DL_EVT
+          ) {
+            if (!eventName) {
+              // this qc has an event condition but no eventName was supplied. so it is not going to match
+              notMatching = true;
+              break;
+            } else {
+              deVal = eventName;
+            }
+          } else {
+            deVal = DataStore.getDataElementValue(qcCondition.param);
+          }
+
+          if (typeof deVal === 'undefined' || deVal === null || deVal === '') {
+            Logger.logDbg(
+              'DE ',
+              qcCondition.param,
+              'was used, but has no value. QC will not qualify'
+            );
+            notMatching = true;
+            continue;
+          }
+
+          // check exclude conditions first
+          if (qcCondition.e && qcCondition.e.length > 0) {
+            if (
+              Utils.isMatch(
+                deVal.toString(),
+                qcCondition.e,
+                !qcCondition.e_cs,
+                qcCondition.e_ect
+              )
+            ) {
+              Logger.logDbg(
+                'QC:Exc: ',
+                qcCondition.param,
+                ' did not qualify. QC: ',
+                qc.nm
+              );
+              notMatching = true;
+              continue;
+            } else {
+              notMatching = false;
+            }
+          }
+
+          if (qcCondition.i && qcCondition.i.length > 0) {
+            if (
+              !Utils.isMatch(
+                deVal.toString(),
+                qcCondition.i,
+                !qcCondition.i_cs,
+                qcCondition.i_ect
+              )
+            ) {
+              Logger.logDbg(
+                'QC:Inc: ',
+                qcCondition.param,
+                ' did not qualify. QC: ',
+                qc.nm
+              );
+              notMatching = true;
+              break;
+            } else {
+              notMatching = false;
+            }
+          } else {
+            // if there is no qc, auto include
+            notMatching = false;
+          }
+        }
+
+        if (!notMatching) {
+          validQcList.push(qc.id);
+          validQcInfo.push({ id: qc.id, nm: qc.nm, st: true });
+        } else {
+          validQcInfo.push({ id: qc.id, nm: qc.nm, st: false });
+        }
+      }
+    } catch (err) {
+      Logger.logDbg('Error processing qc criteria: ', err);
+      Reporter.reportError('m:processQC', err);
+    }
+
+    Logger.logDbg('QC Status: ', validQcInfo);
+    DataStore.setValidQc(validQcList, validQcInfo);
+    return validQcList;
+  }
+}

package/src/processors/tag.processor.ts

@@ -0,0 +1,527 @@
+/**
+ * Finds all the applicable tags based on the true qualification criteria. Method does not return anything
+ * because it uses pass by memory reference. The last 2 paramters (allTagInfo and applicableTagInfo) are
+ * return variables
+ * @param sdkTags
+ * @param sdkProviders
+ * @param validQcList
+ * @param allTagInfo
+ * @param applicableTagInfo
+ */
+import type {
+  HydrateTagInfo,
+  MapLike,
+  ReplaceMode,
+  TagInfoItem,
+} from '../common/app-types';
+import type {
+  ClientSdkParamItem,
+  ClientSdkPrItem,
+  ClientSdkTagItem,
+} from '../models/mp-client-sdk';
+import { Logger } from '../common/logger';
+import { DataStore } from '../common/data-store';
+import { Reporter } from '../common/reporter';
+import { Constants } from '../common/constants';
+import { Utils } from '../common/utils';
+
+export class TagProcessor {
+  private static findApplicableTags(
+    sdkTags: MapLike<ClientSdkTagItem>,
+    sdkProviders: MapLike<ClientSdkPrItem>,
+    validQcList: string[],
+    allTagInfo: TagInfoItem[],
+    applicableTagInfo: TagInfoItem[]
+  ): void {
+    const applicableTags: string[] = [];
+    const tagKeys = Object.keys(sdkTags);
+    const currentEpochSeconds = Math.round(new Date().getTime() / 1000);
+    Logger.logDbg('Total Tag Length: ', tagKeys.length);
+    for (const tagId of tagKeys) {
+      const tag: ClientSdkTagItem | undefined = sdkTags[tagId];
+      if (tag) {
+        let isQualified = true;
+        for (const qc of tag.qc) {
+          if (validQcList.indexOf(qc) === -1) {
+            isQualified = false;
+            allTagInfo.push({
+              id: tagId,
+              nm: tag.nm,
+              status: false,
+              qc,
+              pr: tag.p,
+              prNm: sdkProviders[tag.p]?.nm || '',
+            });
+            break;
+          }
+        }
+        if (isQualified && applicableTags.indexOf(tagId) === -1) {
+          if (this.checkTagDateValidity(currentEpochSeconds, tag.st, tag.ex)) {
+            applicableTags.push(tagId);
+            allTagInfo.push({
+              id: tagId,
+              nm: tag.nm,
+              status: true,
+              qc: tag.qc,
+              pr: tag.p,
+              prNm: sdkProviders[tag.p]?.nm || '',
+            });
+            applicableTagInfo.push({
+              id: tagId,
+              nm: tag.nm,
+              status: true,
+              qc: tag.qc,
+              pr: tag.p,
+              prNm: sdkProviders[tag.p]?.nm || '',
+            });
+          } else {
+            allTagInfo.push({
+              id: tagId,
+              nm: tag.nm,
+              status: false,
+              qc: tag.qc,
+              pr: tag.p,
+              prNm: sdkProviders[tag.p]?.nm || '',
+            });
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Core function which actually puts the tag on page based on the tag type (JS or Image)
+   * @param eventName
+   * @param evtId
+   */
+  static async processTags(eventName: string, evtId: string): Promise<void> {
+    try {
+      Logger.logDbg(
+        'Processing tags for event: ',
+        eventName,
+        ' with id: ',
+        evtId
+      );
+      const allTagInfo: Array<TagInfoItem> = [];
+      const applicableTagInfo: Array<TagInfoItem> = [];
+      const prStatus = DataStore.getPrivacyCompliance();
+      const dataElements = DataStore.getDataElements();
+      const transFunctions = DataStore.getTransFunctions();
+      const sdkTags = DataStore.getSdkTags();
+      const sdkProviders = DataStore.getSdkProviders();
+      const validQcList = DataStore.getValidQcList();
+
+      // Find applicable tags
+      this.findApplicableTags(
+        sdkTags,
+        sdkProviders,
+        validQcList,
+        allTagInfo,
+        applicableTagInfo
+      );
+
+      // set expected tag count, so that the reporter knows when all tags are finished and can report asynchronously
+      Reporter.setExpectedTagCount(applicableTagInfo.length, evtId);
+
+      Logger.logDbg('Applicable Tags: ', applicableTagInfo);
+
+      // process tags one by one
+      for (const tagInfo of applicableTagInfo) {
+        try {
+          Logger.logDbg(`Processing Tag: ${tagInfo.nm} [${tagInfo.id}]`);
+
+          const tag: ClientSdkTagItem | undefined = sdkTags[tagInfo.id];
+
+          if (!tag) {
+            continue;
+          }
+
+          const provider: ClientSdkPrItem | undefined = sdkProviders[tag.p];
+
+          if (!provider) {
+            continue;
+          }
+
+          const result = this.hydrateTag(
+            tagInfo,
+            tag,
+            provider,
+            prStatus,
+            dataElements,
+            transFunctions
+          );
+
+          if (result.isInError) {
+            Logger.logDbg(
+              `Tag ${tagInfo.nm} not processed because of error code: ${result.errCd}`
+            );
+            if (result.errCd === 'NP') {
+              Reporter.reportItem(
+                {
+                  st: Constants.ST_PR_EXC,
+                  t: tagInfo.id,
+                  p: tagInfo.pr,
+                  tNm: tagInfo.nm,
+                  req: result.errMsg,
+                },
+                evtId
+              );
+            } else if (result.errCd === 'PRB') {
+              Reporter.reportItem(
+                {
+                  st: Constants.ST_PR_BL,
+                  t: tagInfo.id,
+                  p: tagInfo.pr,
+                  tNm: tagInfo.nm,
+                  req: result.errMsg,
+                },
+                evtId
+              );
+            } else if (result.errCd === 'REF') {
+              Reporter.reportItem(
+                {
+                  st: Constants.ST_VAL_FAIL,
+                  t: tagInfo.id,
+                  p: tagInfo.pr,
+                  tNm: tagInfo.nm,
+                  req: result.errMsg,
+                },
+                evtId
+              );
+            }
+            continue;
+          }
+
+          const finalUrl = result.content;
+          Logger.logDbg('Final Url :: ', finalUrl);
+
+          if (provider.typ === Constants.PR_TYP_APP) {
+            if (provider.sTyp === Constants.PR_S_TYP_R) {
+              // process and fire app event
+              try {
+                const parsedData = JSON.parse(result.content as string);
+                Utils.triggerEvent(
+                  parsedData.event_bus_name,
+                  parsedData.event_bus_payload
+                );
+                Reporter.reportItem(
+                  {
+                    st: Constants.ST_OK,
+                    t: tagInfo.id,
+                    p: tagInfo.pr,
+                    tNm: tagInfo.nm,
+                    req: parsedData,
+                  },
+                  evtId
+                );
+              } catch (err) {
+                Logger.logError(err);
+                Reporter.reportItem(
+                  {
+                    st: Constants.ST_ERR,
+                    t: tagInfo.id,
+                    p: tagInfo.pr,
+                    tNm: tagInfo.nm,
+                    req: result.content,
+                  },
+                  evtId
+                );
+              }
+            } else {
+              Logger.logError('Unsupported provider type: ' + provider.sTyp);
+            }
+          }
+        } catch (err) {
+          Logger.logError(
+            'Failed loading tag: ',
+            tagInfo.id,
+            ': Name: ',
+            tagInfo.nm,
+            'with error ',
+            err
+          );
+          Reporter.reportItem(
+            {
+              st: Constants.ST_ERR,
+              t: tagInfo.id,
+              p: tagInfo.pr,
+              tNm: tagInfo.nm,
+              req: (err as any)?.stack,
+            },
+            evtId
+          );
+        }
+      }
+    } catch (err) {
+      Logger.logError('Error processing tags: ', err);
+      // TODO: Report as metric to client
+    }
+  }
+
+  /**
+   * Takes all the placeholders in a tag and replaces them with actual values from data elements or
+   * actual static values. Method returns an object with errCd and replaced content and a boolean identifier
+   * to denote if this process failed or not
+   * @param tagInfo
+   * @param tag
+   * @param provider
+   * @param prStatus
+   * @param dataElements
+   * @param transFunctions
+   */
+  private static hydrateTag(
+    tagInfo: TagInfoItem,
+    tag: ClientSdkTagItem,
+    provider: ClientSdkPrItem,
+    prStatus: boolean,
+    dataElements: MapLike<any>,
+    transFunctions: MapLike<any>
+  ): HydrateTagInfo {
+    Logger.logDbg(`Hydrating Tag: ${tagInfo.nm} [${tagInfo.id}]`);
+    if (!provider) {
+      // serious issue. tag is in build sdk but not the appropriate provider
+      Logger.logError(
+        `Not hydrating tag: ${tagInfo.nm} [${tagInfo.id}] because appropriate provider was not found`
+      );
+      return {
+        isInError: true,
+        content: null,
+        errCd: 'NP',
+        errMsg: `Not hydrating tag: ${tagInfo.nm} [${tagInfo.id}] because appropriate provider was not found`,
+      }; // No Provider
+    }
+
+    if (provider.pr === 'B' && !prStatus) {
+      Logger.logDbg(
+        `Not hydrating provider: ${provider.nm} [${tag.p}] because it is blacklisted`
+      );
+      return {
+        isInError: true,
+        content: null,
+        errCd: 'PRB',
+        errMsg: `Not hydrating provider: ${provider.nm} [${tag.p}] because it is blacklisted`,
+      }; // Privacy Blocked
+    }
+
+    // merge both provider and client tag params into one - tag param overwrites provider params
+    const params: MapLike<ClientSdkParamItem | undefined> =
+      Utils.mergeMaps<ClientSdkParamItem>(
+        undefined,
+        provider.rParams,
+        tag.rParams
+      );
+
+    if (provider.typ === 'app' && provider.sTyp === 'r') {
+      // this is o app type provider. no need to find place-holders, just convert params to an object and prepare the json object
+      return this.resourceParamsToActualValues(
+        Object.values(params),
+        dataElements,
+        transFunctions
+      );
+    } else {
+      // make tag url
+      const preReplaceUrl: string = provider.url + (tag.url ? tag.url : '');
+      const finalUrl: string = provider.url + (tag.url ? tag.url : '');
+
+      // find placeholder values
+      const placeHolders: string[] = this.findPlaceHolders(preReplaceUrl);
+      // process tag attributes
+      return this.replacePlaceHolders(
+        finalUrl,
+        placeHolders,
+        dataElements,
+        transFunctions,
+        params,
+        provider.chld || tag.chld,
+        'rph'
+      );
+    }
+  }
+
+  private static findPlaceHolders(content: string): string[] {
+    const placeHolders: string[] = [];
+    let match = Constants.PLACEHOLDER_REGEX.exec(content);
+    while (match !== null) {
+      placeHolders.push(match[2]);
+      match = Constants.PLACEHOLDER_REGEX.exec(content);
+    }
+    return placeHolders;
+  }
+
+  private static resourceParamsToActualValues(
+    params: ClientSdkParamItem[],
+    deItems: MapLike,
+    transFunctions: MapLike
+  ): HydrateTagInfo {
+    // resolve all param values and convert them into a temporary structure
+    const paramValueArray: MapLike = {};
+
+    for (const param of params) {
+      if (param.val_src !== 'CHILDREN') {
+        const deVal = this.parseParamValue(param, deItems, transFunctions);
+
+        if (param.rqd && typeof deVal === 'undefined') {
+          return {
+            isInError: true,
+            content: '',
+            errCd: 'REF',
+            errMsg: `Tag validation failed. Parameter ${param.nm} is marked as mandatory, but no value was found in source.`,
+          };
+        }
+
+        paramValueArray[param.fKey] = deVal;
+      }
+    }
+
+    const op = Utils.unflattenObject(paramValueArray);
+
+    return {
+      isInError: false,
+      content: JSON.stringify(op),
+      errCd: null,
+      errMsg: null,
+    };
+  }
+
+  private static parseParamValue(
+    paramItem: ClientSdkParamItem,
+    deItems: MapLike<any>,
+    transFunctions: MapLike<any>
+  ): any {
+    let paramValue = undefined;
+    if (paramItem.sv || paramItem.de || paramItem.tfId) {
+      if (paramItem.sv) {
+        paramValue = paramItem.sv;
+      } else if (paramItem.de) {
+        paramValue = deItems[paramItem.de];
+      } else if (paramItem.tfId) {
+        paramValue = transFunctions[paramItem.tfId];
+      }
+
+      paramValue = Utils.applyTransformationResourceParam(
+        paramValue,
+        paramItem.tf
+      );
+      return paramValue;
+    } else {
+      return undefined;
+    }
+  }
+
+  private static replacePlaceHolders(
+    content: string,
+    placeHolders: string[],
+    deItems: MapLike<any>,
+    transFunctions: MapLike<any>,
+    params: MapLike<ClientSdkParamItem>,
+    hasChildren: boolean,
+    replaceMode: ReplaceMode
+  ): HydrateTagInfo {
+    let isInError = false;
+    let errMsg;
+
+    if (!params) {
+      return {
+        isInError: false,
+        content,
+        errCd: null,
+        errMsg: 'No parameters where found to process in this tag',
+      };
+    }
+
+    if (hasChildren) {
+      // convert the flattened parameters to parent - child format. this is inside a condition
+      // because we may not have a lot of JSON type parameters and we can save some processing time by limiting
+      // when this is done
+      params = Utils.unFlattenResourceParams(Object.values(params));
+    }
+
+    for (const ph of placeHolders) {
+      try {
+        const tagParam: ClientSdkParamItem = params[ph];
+        if (tagParam) {
+          if (tagParam.children && tagParam.children.length > 0) {
+            const paramValue: MapLike<any> = {};
+            for (const childParam of tagParam.children) {
+              paramValue[childParam.nm] = this.parseParamValue(
+                childParam,
+                deItems,
+                transFunctions
+              );
+            }
+            content = this.replaceValues(
+              ph,
+              content,
+              JSON.stringify(paramValue),
+              replaceMode
+            );
+          } else {
+            const paramValue = this.parseParamValue(
+              tagParam,
+              deItems,
+              transFunctions
+            );
+            if (typeof paramValue === 'object') {
+              content = this.replaceValues(
+                ph,
+                content,
+                JSON.stringify(paramValue),
+                replaceMode
+              );
+            } else {
+              content = this.replaceValues(
+                ph,
+                content,
+                paramValue,
+                replaceMode
+              );
+            }
+          }
+        } else {
+          // TODO: Report
+          // place holder was found but the corresponding item was not found in tag resource params
+          Logger.logDbg(
+            'place holder:',
+            ph,
+            ', was found but the corresponding item was not found in tag resource params'
+          );
+        }
+      } catch (err) {
+        isInError = true;
+        errMsg = (err as any)?.stack;
+        break;
+      }
+    }
+
+    return {
+      isInError,
+      content,
+      errCd: isInError ? 'REF' : null,
+      errMsg: errMsg,
+    };
+  }
+
+  private static checkTagDateValidity(
+    currentEpochSeconds: number,
+    tagStart: number,
+    tagEnd: number
+  ): boolean {
+    return currentEpochSeconds >= tagStart && currentEpochSeconds <= tagEnd;
+  }
+
+  private static replaceValues(
+    placeHolder: string,
+    content: string,
+    val: any,
+    replaceMode: ReplaceMode
+  ): string {
+    let replaceVal: string;
+    if (replaceMode === 'kph') {
+      replaceVal = val && val !== '' ? val : `{{${placeHolder}}`;
+    } else if (replaceMode === 'rph') {
+      replaceVal = val && val !== '' ? val : '';
+    }
+    content = content.split(`{{${placeHolder}}}`).join(replaceVal);
+    return content;
+  }
+}