vwo-fme-node-sdk 1.0.0

package/lib/utils/MegUtil.ts

@@ -0,0 +1,408 @@
+import { CampaignDecisionService } from '../services/CampaignDecisionService';
+import { evaluateRule } from '../api/GetFlag';
+import { CampaignTypeEnum } from '../enums/campaignTypeEnum';
+import { SettingsModel } from '../models/SettingsModel';
+import {
+  getBucketingSeed,
+  getCampaignIdsFromFeatureKey,
+  getCampaignsByGroupId,
+  getCampaignVariation,
+  getFeatureKeysFromCampaignIds,
+  getRuleTypeUsingCampaignIdFromFeature,
+  setCampaignAllocation,
+} from './CampaignUtil';
+import { isObject } from './DataTypeUtil';
+import { cloneObject, getFeatureFromKey, getSpecificRulesBasedOnType } from './FunctionUtil';
+import { checkWhitelistingAndPreSeg, evaluateTrafficAndGetVariation } from './DecisionUtil';
+import { StorageDecorator } from '../decorators/StorageDecorator';
+import { StorageService } from '../services/StorageService';
+import { VariationModel } from '../models/VariationModel';
+import { CampaignModel } from '../models/CampaignModel';
+import { Deferred } from './PromiseUtil';
+import { resolve } from 'path';
+import { LogManager } from '../modules/logger';
+import { Constants } from '../constants';
+import { DecisionMaker } from '../modules/decision-maker';
+
+export const evaluateGroups = async (
+  settings: SettingsModel,
+  featureKey: any,
+  feature: any,
+  listOfMegCampaignsGroups: any[],
+  evaluatedFeatureMap: Map<string, any>,
+  context: any,
+  storageService: StorageService,
+  campaignToSkip: any[],
+  decision: any,
+): Promise<any> => {
+  let featureToSkip = [];
+  let eligibleCampaignsForGroup: Map<string, any[]> = new Map();
+
+  // get all feature keys from the list of meg campaigns
+  // evaluate each feature and get all campaigns for the feature
+  // add the campaigns if they are present in the groupto campaignMap
+  // check the eligible campaigns
+  for (let i = 0; i < listOfMegCampaignsGroups.length; i++) {
+    let campaignMap: Map<string, any[]> = new Map();
+    let groupId = listOfMegCampaignsGroups[i];
+    const { featureKeys, groupCampaignIds } = getFeatureKeysFromGroup(settings, groupId);
+    for (const featureKey of featureKeys) {
+      const feature = getFeatureFromKey(settings, featureKey);
+      const featureCampaignIds = getCampaignIdsFromFeatureKey(settings, featureKey);
+      if (featureToSkip.includes(featureKey)) {
+        continue;
+      }
+      const result = await evaluateFeatureRollOutRules(settings, feature, evaluatedFeatureMap, featureToSkip, context);
+      if (result) {
+        settings.getCampaigns().forEach((campaign) => {
+          // groupCampaignIds.includes(campaign.getId()) -> campaig we are adding should be in the group
+          // featureCampaignIds.includes(campaign.getId()) -> checks that campaign should be part of the feature that we evaluated
+          if (groupCampaignIds.includes(campaign.getId()) && featureCampaignIds.includes(campaign.getId())) {
+            if (!campaignMap.has(featureKey)) {
+              campaignMap.set(featureKey, []);
+            }
+            if (campaignMap.get(featureKey).findIndex((item) => item.key === campaign.getKey()) === -1) {
+              campaignMap.get(featureKey).push(campaign);
+            }
+          }
+        });
+      }
+    }
+    let campaignList = await getEligbleCampaigns(settings, campaignMap, context, storageService);
+    eligibleCampaignsForGroup.set(groupId, campaignList);
+  }
+  return await evaluateEligibleCampaigns(
+    settings,
+    featureKey,
+    feature,
+    eligibleCampaignsForGroup,
+    context,
+    campaignToSkip,
+    decision,
+  );
+};
+
+export function getFeatureKeysFromGroup(settings: SettingsModel, groupId: any) {
+  let groupCampaignIds = getCampaignsByGroupId(settings, groupId);
+  let featureKeys = getFeatureKeysFromCampaignIds(settings, groupCampaignIds);
+  return { featureKeys, groupCampaignIds };
+}
+
+const evaluateFeatureRollOutRules = async (
+  settings: any,
+  feature: any,
+  evaluatedFeatureMap: Map<string, any>,
+  featureToSkip: any[],
+  context: any,
+): Promise<any> => {
+  if (evaluatedFeatureMap.has(feature.key) && evaluatedFeatureMap.get(feature.key).hasOwnProperty('rolloutId')) {
+    return true;
+  }
+  const rollOutRules = getSpecificRulesBasedOnType(settings, feature.key, CampaignTypeEnum.ROLLOUT);
+  if (rollOutRules.length > 0) {
+    let ruleToTestForTraffic = null;
+    for (const rule of rollOutRules) {
+      const [evaluateRuleResult] = await evaluateRule(settings, feature, rule, context, false, {});
+      if (evaluateRuleResult) {
+        ruleToTestForTraffic = rule;
+        break;
+      }
+      continue;
+    }
+    if (ruleToTestForTraffic !== null) {
+      const campaign = new CampaignModel().modelFromDictionary(ruleToTestForTraffic);
+      const variation = evaluateTrafficAndGetVariation(settings, campaign, context.user.id);
+      if (isObject(variation) && Object.keys(variation).length > 0) {
+        evaluatedFeatureMap.set(feature.key, {
+          rolloutId: ruleToTestForTraffic.id,
+          rolloutKey: ruleToTestForTraffic.key,
+          rolloutVariationId: ruleToTestForTraffic.variations[0].id,
+        });
+        return true;
+      }
+    }
+    // no rollout rule passed
+    featureToSkip.push(feature.key);
+    return false;
+  }
+  // no rollout rule, evaluate experiments
+  LogManager.Instance.debug(`MEG: No rollout rule found for feature ${feature.key}, evaluating experiments...`);
+  return true;
+};
+
+const getEligbleCampaigns = async (
+  settings: any,
+  campaignMap: any,
+  context: any,
+  storageService: StorageService,
+): Promise<any> => {
+  let eligibleCampaigns = [];
+  let eligibleCampaignsWithStorage = [];
+  let inEligibleCampaigns = [];
+  const campaignMapArray = Array.from<[string, CampaignModel[]]>(campaignMap);
+  for (const [featureKey, campaigns] of campaignMapArray) {
+    for (const campaign of campaigns) {
+      const storedData: Record<any, any> = await new StorageDecorator().getFeatureFromStorage(
+        featureKey,
+        context.user,
+        storageService,
+      );
+      if (storedData?.experimentVariationId) {
+        if (storedData.experimentKey && storedData.experimentKey === campaign.getKey()) {
+          const variation: VariationModel = getCampaignVariation(
+            settings,
+            storedData.experimentKey,
+            storedData.experimentVariationId,
+          );
+          if (variation) {
+            LogManager.Instance.debug(
+              `MEG: Campaign ${storedData.experimentKey} found in storage for user ${context.user.id}`,
+            );
+            eligibleCampaignsWithStorage.push(campaign);
+            continue;
+          }
+        }
+      }
+      if (
+        (await new CampaignDecisionService().getDecision(
+          new CampaignModel().modelFromDictionary(campaign),
+          settings,
+          context,
+        )) &&
+        new CampaignDecisionService().isUserPartOfCampaign(context.user.id, campaign)
+      ) {
+        LogManager.Instance.debug(`MEG: Campaign ${campaign.getKey()} is eligible for user ${context.user.id}`);
+        eligibleCampaigns.push(campaign);
+        continue;
+      }
+      inEligibleCampaigns.push(campaign);
+    }
+  }
+  return Promise.resolve({
+    eligibleCampaigns,
+    eligibleCampaignsWithStorage,
+    inEligibleCampaigns,
+  });
+};
+
+const evaluateEligibleCampaigns = async (
+  settings: any,
+  featureKey: any,
+  feature: any,
+  eligibleCampaignsForGroup: Map<string, any[]>,
+  context: any,
+  campaignToSkip: any[],
+  decision: any,
+): Promise<any> => {
+  // getCampaignIds from featureKey
+  let winnerFromEachGroup = [];
+  const campaignIds = getCampaignIdsFromFeatureKey(settings, featureKey);
+  eligibleCampaignsForGroup.forEach((campaignList: any, groupId) => {
+    let megAlgoNumber =
+      typeof settings.groups[groupId].et !== 'undefined' ? settings.groups[groupId].et : Constants.RANDOM_ALGO;
+    if (campaignList.eligibleCampaignsWithStorage.length === 1) {
+      winnerFromEachGroup.push(campaignList.eligibleCampaignsWithStorage[0]);
+      LogManager.Instance.debug(
+        `MEG: Campaign ${campaignList.eligibleCampaignsWithStorage[0].getKey()} is the winner for group ${groupId} for user ${context.user.id}`,
+      );
+    } else if (campaignList.eligibleCampaignsWithStorage.length > 1 && megAlgoNumber === Constants.RANDOM_ALGO) {
+      winnerFromEachGroup.push(
+        normalizeAndFindWinningCampaign(campaignList.eligibleCampaignsWithStorage, context, campaignIds, groupId),
+      );
+    } else if (campaignList.eligibleCampaignsWithStorage.length > 1) {
+      winnerFromEachGroup.push(
+        advancedAlgoFindWinningCampaign(
+          settings,
+          campaignList.eligibleCampaignsWithStorage,
+          context,
+          campaignIds,
+          groupId,
+        ),
+      );
+    }
+
+    if (campaignList.eligibleCampaignsWithStorage.length === 0) {
+      if (campaignList.eligibleCampaigns.length === 1) {
+        winnerFromEachGroup.push(campaignList.eligibleCampaigns[0]);
+        LogManager.Instance.debug(
+          `MEG: Campaign ${campaignList.eligibleCampaigns[0].getKey()} is the winner for group ${groupId} for user ${context.user.id}`,
+        );
+      } else if (campaignList.eligibleCampaigns.length > 1 && megAlgoNumber === Constants.RANDOM_ALGO) {
+        winnerFromEachGroup.push(
+          normalizeAndFindWinningCampaign(campaignList.eligibleCampaigns, context, campaignIds, groupId),
+        );
+      } else if (campaignList.eligibleCampaigns.length > 1) {
+        winnerFromEachGroup.push(
+          advancedAlgoFindWinningCampaign(settings, campaignList.eligibleCampaigns, context, campaignIds, groupId),
+        );
+      }
+    }
+  });
+  return await campaignToReturn(
+    settings,
+    feature,
+    eligibleCampaignsForGroup,
+    winnerFromEachGroup,
+    context,
+    campaignIds,
+    campaignToSkip,
+    decision,
+  );
+};
+
+const normalizeAndFindWinningCampaign = (
+  shortlistedCampaigns: any[],
+  context: any,
+  calledCampaignIds: any[],
+  groupId: any,
+): any => {
+  // normalise the weights of all the shortlisted campaigns
+  shortlistedCampaigns.forEach((campaign) => {
+    campaign.weight = Math.floor(100 / shortlistedCampaigns.length);
+  });
+
+  // make shortlistedCampaigns as array of VariationModel
+  shortlistedCampaigns = shortlistedCampaigns.map((campaign) => new VariationModel().modelFromDictionary(campaign));
+
+  // re-distribute the traffic for each camapign
+  setCampaignAllocation(shortlistedCampaigns);
+  let winnerCampaign = new CampaignDecisionService().getVariation(
+    shortlistedCampaigns,
+    new DecisionMaker().calculateBucketValue(getBucketingSeed(context.user.id, undefined, groupId)),
+  );
+
+  LogManager.Instance.debug(
+    `MEG Random: Campaign ${winnerCampaign.getKey()} is the winner for group ${groupId} for user ${context.user.id}`,
+  );
+
+  if (winnerCampaign && calledCampaignIds.includes(winnerCampaign.getId())) {
+    return winnerCampaign;
+  }
+  return null;
+};
+
+const advancedAlgoFindWinningCampaign = (
+  settings: any,
+  shortlistedCampaigns: any[],
+  context: any,
+  calledCampaignIds: any[],
+  groupId: any,
+) => {
+  let winnerCampaign = null;
+  let found = false; // flag to check whether winnerCampaign has been found or not and helps to break from the outer loop
+  let priorityOrder = typeof settings.groups[groupId].p !== 'undefined' ? settings.groups[groupId].p : {};
+  let wt = typeof settings.groups[groupId].wt !== 'undefined' ? settings.groups[groupId].wt : {};
+
+  for (let i = 0; i < priorityOrder.length; i++) {
+    for (let j = 0; j < shortlistedCampaigns.length; j++) {
+      if (shortlistedCampaigns[j].id === priorityOrder[i]) {
+        winnerCampaign = cloneObject(shortlistedCampaigns[j]);
+        found = true;
+        break;
+      }
+    }
+    if (found === true) break;
+  }
+
+  // If winnerCampaign not found through Priority, then go for weighted Random distribution and for that,
+  // Store the list of campaigns (participatingCampaigns) out of shortlistedCampaigns and their corresponding weights present in weightage distribution array (wt)
+  if (winnerCampaign === null) {
+    let participatingCampaignList = [];
+    // iterate over shortlisted campaigns and add weights from the weight array
+    for (let i = 0; i < shortlistedCampaigns.length; i++) {
+      let campaignId = shortlistedCampaigns[i].id;
+      if (typeof wt[campaignId] !== 'undefined') {
+        let clonedCampaign = cloneObject(shortlistedCampaigns[i]);
+        clonedCampaign.weight = wt[campaignId];
+        participatingCampaignList.push(clonedCampaign);
+      }
+    }
+    /* Finding winner campaign using weighted Distibution :
+       1. Re-distribute the traffic by assigning range values for each camapign in particaptingCampaignList 
+       2. Calculate bucket value for the given userId and groupId
+       3. Get the winnerCampaign by checking the Start and End Bucket Allocations of each campaign
+      */
+
+    // make participatingCampaignList as array of VariationModel
+    participatingCampaignList = participatingCampaignList.map((campaign) =>
+      new VariationModel().modelFromDictionary(campaign),
+    );
+    setCampaignAllocation(participatingCampaignList);
+    winnerCampaign = new CampaignDecisionService().getVariation(
+      participatingCampaignList,
+      new DecisionMaker().calculateBucketValue(getBucketingSeed(context.user.id, undefined, groupId)),
+    );
+  }
+  // WinnerCampaign should not be null, in case when winnerCampaign hasn't been found through PriorityOrder and
+  // also shortlistedCampaigns and wt array does not have a single campaign id in common
+  LogManager.Instance.debug(
+    `MEG Advance: Campaign ${winnerCampaign.key} is the winner for group ${groupId} for user ${context.user.id}`,
+  );
+  if (calledCampaignIds.includes(winnerCampaign.id)) {
+    return winnerCampaign;
+  }
+  return null;
+};
+
+const campaignToReturn = async (
+  settings: any,
+  feature: any,
+  eligibleCampaignsForGroup: any,
+  winnerCampaigns: any,
+  context: any,
+  priorityCampaignIds: any,
+  campaignToSkip: any[],
+  decision: any,
+): Promise<any> => {
+  const eligibleCampaignsForGroupArray = Array.from<[string, any[]]>(eligibleCampaignsForGroup);
+  for (const [groupId, campaignList] of eligibleCampaignsForGroupArray) {
+    let winnerFound = false;
+    let campaignToReturn = null;
+    for (const campaignId of priorityCampaignIds) {
+      const winnerCampaign = winnerCampaigns.find((campaign) => campaign?.id === campaignId);
+      if (winnerCampaign) {
+        campaignToReturn = winnerCampaign;
+        winnerFound = true;
+        break;
+      }
+      if (
+        campaignToSkip.includes(campaignId) ||
+        getRuleTypeUsingCampaignIdFromFeature(feature, campaignId) === CampaignTypeEnum.ROLLOUT
+      ) {
+        continue;
+      }
+      // check if campaignId is present in eligibleCampaignsWithStorage or eligibleCampaigns or inEligibleCampaigns
+      const campaign =
+        campaignList['eligibleCampaignsWithStorage'].find((campaign) => campaign.id === campaignId) ||
+        campaignList['eligibleCampaigns'].find((campaign) => campaign.id === campaignId) ||
+        campaignList['inEligibleCampaigns'].find((campaign) => campaign.id === campaignId);
+      if (campaign) {
+        continue;
+      } else {
+        campaignToSkip.push(campaignId);
+        return [false, null, null];
+      }
+    }
+    if (winnerFound) {
+      LogManager.Instance.info(`MEG: Campaign ${campaignToReturn.key} is the winner for user ${context.user.id}`);
+      const [megResult, whitelistedVariationInfoWithCampaign] = await evaluateRule(
+        settings,
+        feature,
+        campaignToReturn,
+        context,
+        true,
+        decision,
+      );
+      if (
+        isObject(whitelistedVariationInfoWithCampaign) &&
+        Object.keys(whitelistedVariationInfoWithCampaign).length > 0
+      ) {
+        whitelistedVariationInfoWithCampaign.experiementId = campaignToReturn.id;
+        whitelistedVariationInfoWithCampaign.experiementKey = campaignToReturn.key;
+        return [true, whitelistedVariationInfoWithCampaign, null];
+      }
+      return [true, whitelistedVariationInfoWithCampaign, campaignToReturn];
+    }
+  }
+  return [false, null, null];
+};

package/lib/utils/NetworkUtil.ts

@@ -0,0 +1,262 @@
+import { getUUID } from './UuidUtil';
+import { getRandomNumber, getCurrentUnixTimestamp, getCurrentUnixTimestampInMillis } from './FunctionUtil';
+
+import { dynamic } from '../types/common';
+import { Constants } from '../constants';
+import { SettingsModel } from '../models/SettingsModel';
+import UrlService from '../services/UrlService';
+import { UrlEnum } from '../enums/UrlEnum';
+import { LogManager } from '../modules/logger';
+import { EventEnum } from '../enums/EventEnum';
+import { NetworkManager } from '../modules/networking';
+import { RequestModel } from '../modules/networking';
+import { HTTPS_PROTOCOL } from '../constants/url';
+import { ResponseModel } from '../modules/networking';
+import { isObject } from './DataTypeUtil';
+import { HeadersEnum } from '../enums/HeadersEnum';
+
+export class NetworkUtil {
+  getBasePropertiesForBulk(accountId: string, userId: string): Record<string, dynamic> {
+    const path: Record<string, dynamic> = {
+      sId: getCurrentUnixTimestamp(),
+      u: getUUID(userId, accountId),
+    };
+    return path;
+  }
+
+  getSettingsPath(apikey: string, accountId: any): Record<string, dynamic> {
+    const path: Record<string, dynamic> = {
+      i: `${apikey}`,
+      r: Math.random(),
+      a: accountId,
+    };
+    return path;
+  }
+
+  getTrackEventPath(event: string, accountId: string, userId: string): Record<string, dynamic> {
+    const path: Record<string, dynamic> = {
+      event_type: event,
+      account_id: accountId,
+      uId: userId,
+      u: getUUID(userId, accountId),
+      sdk: Constants.SDK_NAME,
+      'sdk-v': Constants.SDK_VERSION,
+      random: getRandomNumber(),
+      ap: Constants.AP,
+      sId: getCurrentUnixTimestamp(),
+      ed: JSON.stringify({ p: 'server' }),
+    };
+
+    return path;
+  }
+
+  getEventBatchingQueryParams(accountId: string): Record<string, dynamic> {
+    const path: Record<string, dynamic> = {
+      a: accountId,
+      sd: Constants.SDK_NAME,
+      sv: Constants.SDK_VERSION,
+    };
+
+    return path;
+  }
+
+  /**
+   * Builds generic properties for different tracking calls required by VWO servers.
+   * @param {Object} configObj
+   * @param {String} eventName
+   * @returns properties
+   */
+  getEventsBaseProperties(setting: any, eventName, visitorUserAgent = '', ipAddress = ''): any {
+    const sdkKey = setting.sdkKey;
+
+    let properties = Object.assign({
+      en: eventName,
+      a: setting.accountId,
+      env: sdkKey,
+      eTime: getCurrentUnixTimestampInMillis(),
+      random: getRandomNumber(),
+      p: 'FS',
+      visitor_ua: visitorUserAgent,
+      visitor_ip: ipAddress,
+    });
+
+    properties.url = Constants.HTTPS_PROTOCOL + UrlService.getBaseUrl() + UrlEnum.EVENTS;
+    return properties;
+  }
+
+  /**
+   * Builds generic payload required by all the different tracking calls.
+   * @param {Object} settings   settings file
+   * @param {String} userId     user id
+   * @param {String} eventName  event name
+   * @returns properties
+   */
+  getEventBasePayload(settings: any, userId: any, eventName: string, visitorUserAgent = '', ipAddress = '') {
+    const uuid = getUUID(userId, settings.accountId);
+    const sdkKey = settings.sdkKey;
+
+    let props: {
+      vwo_sdkName: string;
+      vwo_sdkVersion: string;
+      vwo_envKey: any;
+      id?: any;
+      variation?: any;
+      isFirst?: any;
+      isCustomEvent?: boolean;
+    } = {
+      vwo_sdkName: Constants.SDK_NAME,
+      vwo_sdkVersion: Constants.SDK_VERSION,
+      vwo_envKey: sdkKey,
+    };
+
+    let properties = {
+      d: {
+        msgId: `${uuid}-${getCurrentUnixTimestampInMillis()}`,
+        visId: uuid,
+        sessionId: getCurrentUnixTimestamp(),
+        visitor_ua: visitorUserAgent,
+        visitor_ip: ipAddress,
+        event: {
+          props: props,
+          name: eventName,
+          time: getCurrentUnixTimestampInMillis(),
+        },
+        visitor: {
+          props: {
+            vwo_fs_environment: sdkKey,
+          },
+        },
+      },
+    };
+
+    return properties;
+  }
+
+  /**
+   * Builds payload to track the visitor.
+   * @param {Object} configObj
+   * @param {String} userId
+   * @param {String} eventName
+   * @param {String} campaignId
+   * @param {Number} variationId
+   * @returns track-user payload
+   */
+  getTrackUserPayloadData(
+    settings: any,
+    userId: any,
+    eventName: string,
+    campaignId: any,
+    variationId: any,
+    visitorUserAgent = '',
+    ipAddress = '',
+  ) {
+    const properties = this.getEventBasePayload(settings, userId, eventName, visitorUserAgent, ipAddress);
+
+    properties.d.event.props.id = campaignId;
+    properties.d.event.props.variation = variationId;
+    properties.d.event.props.isFirst = 1;
+
+    LogManager.Instance.debug(
+      `IMPRESSION_FOR_EVENT_ARCH_TRACK_USER: Impression built for vwo_variationShown event for Account ID:${settings.accountId}, User ID:${userId}, and Campaign ID:${campaignId}`,
+    );
+
+    return properties;
+  }
+
+  getTrackGoalPayloadData(
+    settings: any,
+    userId: any,
+    eventName: string,
+    eventProperties: any,
+    visitorUserAgent = '',
+    ipAddress = '',
+  ) {
+    const properties = this.getEventBasePayload(settings, userId, eventName, visitorUserAgent, ipAddress);
+    properties.d.event.props.isCustomEvent = true;
+    properties.d.event.props.variation = 1; // temporary value
+    properties.d.event.props.id = 1; // temporary value
+
+    if (eventProperties && isObject(eventProperties) && Object.keys(eventProperties).length > 0) {
+      for (const prop in eventProperties) {
+        properties.d.event.props[prop] = eventProperties[prop];
+      }
+    }
+
+    LogManager.Instance.debug(
+      `IMPRESSION_FOR_EVENT_ARCH_TRACK_GOAL: Impression built for ${eventName} event for Account ID:${settings.accountId}, User ID:${userId}`,
+    );
+
+    return properties;
+  }
+
+  getAttributePayloadData(
+    settings: any,
+    userId: any,
+    eventName: string,
+    attributeKey: any,
+    attributeValue: any,
+    visitorUserAgent = '',
+    ipAddress = '',
+  ) {
+    const properties = this.getEventBasePayload(settings, userId, eventName, visitorUserAgent, ipAddress);
+
+    properties.d.event.props.isCustomEvent = true;
+    properties.d.event.props[Constants.VWO_FS_ENVIRONMENT] = settings.sdkKey;
+    properties.d.visitor.props[attributeKey] = attributeValue;
+
+    LogManager.Instance.debug(
+      `IMPRESSION_FOR_EVENT_ARCH_SYNC_VISITOR_PROP: Impression built for ${eventName} event for Account ID:${settings.accountId}, User ID:${userId}`,
+    );
+
+    return properties;
+  }
+
+  sendPostApiRequest(properties: any, payload: any) {
+    NetworkManager.Instance.attachClient();
+
+    const headers: Record<string, string> = {};
+
+    const userAgent = payload.d.visitor_ua;
+    const ipAddress = payload.d.visitor_ip;
+
+    // Set headers
+    if (userAgent) headers[HeadersEnum.USER_AGENT] = userAgent;
+    if (ipAddress) headers[HeadersEnum.IP] = ipAddress;
+
+    const request: RequestModel = new RequestModel(
+      UrlService.getBaseUrl(),
+      'POST',
+      UrlEnum.EVENTS,
+      properties,
+      payload,
+      headers,
+      null,
+      UrlService.getPort(),
+    );
+
+    NetworkManager.Instance.post(request).catch((err: ResponseModel) => {
+      console.log('error', err);
+    });
+  }
+
+  async sendGetApiRequest(properties: any, endpoint: any): Promise<any> {
+    NetworkManager.Instance.attachClient();
+    const request: RequestModel = new RequestModel(
+      UrlService.getBaseUrl(),
+      'Get',
+      endpoint,
+      properties,
+      null,
+      null,
+      null,
+      UrlService.getPort(),
+    );
+    try {
+      const response: ResponseModel = await NetworkManager.Instance.get(request);
+      return response; // Return the response model
+    } catch (err) {
+      console.error('Error occurred while sending GET request:', err);
+      return null;
+    }
+  }
+}

package/lib/utils/PromiseUtil.ts

@@ -0,0 +1,10 @@
+import { dynamic } from '../types/common';
+
+export function Deferred(): void {
+  this.promise = new Promise((resolve: dynamic, reject: dynamic) => {
+    this.resolve = resolve;
+    this.reject = reject;
+  });
+
+  return this;
+}

package/lib/utils/SettingsUtil.ts

@@ -0,0 +1,18 @@
+import { setVariationAllocation } from '../utils/CampaignUtil';
+import { SettingsModel } from '../models/SettingsModel';
+import { CampaignModel } from '../models/CampaignModel';
+import { dynamic } from '../types/common';
+import { FeatureModel } from '../models/FeatureModel';
+
+export function processSettings(settings: SettingsModel): SettingsModel {
+  const parsedSettings: SettingsModel = new SettingsModel(settings);
+  const features: Array<FeatureModel> = parsedSettings?.getFeatures();
+  // features.forEach((feature: FeatureModel) => {
+  //   feature.getCampaigns().forEach((campaign: CampaignModel) => {
+  //     campaign.setFeatureDetails(feature.getId(), feature.getKey());
+  //     setVariationAllocation(campaign.getVariations(), feature.getVariables());
+  //   });
+  // });
+
+  return parsedSettings;
+}