Name

sn_rf.RFHistoryService

Description

Class for sn_rf_recommendation_history table utility functions.

Script

var RFHistoryService = Class.create();

RFHistoryService.create = function(targetGr, expId, actionId, isPrimary, status, ruleOutputs, ruleOutputsString) {
  try {
      var gr = new GlideRecord(RFConstants.tables.SN_RF_RECOMENDATION_HISTORY);
      gr.initialize();
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_EXPERIENCE] = expId;
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_ACTION] = actionId;
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS] = status;
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_IS_PRIMARY_ACTION] = isPrimary;
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_TABLE] = targetGr.getTableName();
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD] = targetGr.getValue(RFConstants.fields.SYS_ID);
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_SNAPSHOT_MOD_COUNT] = targetGr.getValue(RFConstants.fields.SYS_MOD_COUNT);
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RULE_OUTPUT] = ruleOutputsString;
      gr[RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_UNIQUE_VALUE] = RFHistoryService.calculateUniqueValue(ruleOutputs);
      return gr.insert();
  } catch (e) {
      new RFLogger("RFHistoryService - create").logError("Unable to add the history record for action " + actionId +
          " and context record " + targetGr.sys_id + ". Error: " + e);
  }
};

RFHistoryService.calculateUniqueValue = function(ruleOutputs) {
  var uniqueKeys = ruleOutputs[RFConstants.evaluatorVariable.UNIQUE_KEYS_INTERNAL];
  if (!uniqueKeys || !uniqueKeys.length) {
      return RFActionService.serializeEvaluationOutput(ruleOutputs);
  }
  var uniqueValue = "";
  uniqueKeys.sort();
  for (var keyIdx = 0; keyIdx < uniqueKeys.length; keyIdx++) {
      var key = uniqueKeys[keyIdx];
      var value = ruleOutputs[key];
      value = value.isValidRecord ? value.getValue(RFConstants.fields.SYS_ID) : value;
      uniqueValue += (key + ":" + value + ",");
  }
  return uniqueValue;
};

RFHistoryService.getCountForRuleId = function(ruleID) {
  var agg = new GlideAggregate(RFConstants.tables.SN_RF_RECOMENDATION_HISTORY);
  agg.addAggregate('COUNT(DISTINCT', RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD);
  agg.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_RULE, ruleID);
  agg.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.COMPLETED);
  agg.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_IS_PRIMARY_ACTION, true);
  agg.setGroup(false);
  agg.query();
  if (agg.next()) {
      return agg.getAggregate('COUNT(DISTINCT', RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD);
  }
  return 0;
};

RFHistoryService.isCompleted = function(targetGr, expId, ruleOutputs, actionId) {
  var gr = new GlideRecord(RFConstants.tables.SN_RF_RECOMENDATION_HISTORY);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_TABLE, targetGr.getTableName());
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD, targetGr.getValue(RFConstants.fields.SYS_ID));
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, "!=", RFConstants.historyStatus.REVERTED);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_EXPERIENCE, expId);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_UNIQUE_VALUE, RFHistoryService.calculateUniqueValue(ruleOutputs));

  if (actionId) {
      gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_ACTION, actionId);
  } else {
      gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_IS_PRIMARY_ACTION, true).addOrCondition(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.DISCARDED);
  }
  gr.query();
  if (gr.next()) {
      return gr;
  }
};

RFHistoryService.markReverted = function(targetGr, expId, actionId, ruleOutputs) {
  if (!actionId || !expId) {
      return;
  }
  var gr = new GlideRecord(RFConstants.tables.SN_RF_RECOMENDATION_HISTORY);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_TABLE, targetGr.getTableName());
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD, targetGr.getValue(RFConstants.fields.SYS_ID));
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.COMPLETED);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_EXPERIENCE, expId);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_UNIQUE_VALUE, RFHistoryService.calculateUniqueValue(ruleOutputs));
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_ACTION, actionId);

  gr.query();
  if (gr.next()) {
      gr.status = RFConstants.historyStatus.REVERTED;
      return gr.update();
  }
};

RFHistoryService.getHistoryForRecord = function(tableName, sysId) {
  var gr = new GlideRecord(RFConstants.tables.SN_RF_RECOMENDATION_HISTORY);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_TABLE, tableName);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_TARGET_RECORD, sysId);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.COMPLETED).addOrCondition(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.DISCARDED);
  gr.addQuery(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_IS_PRIMARY_ACTION, RFConstants.queryConstants.TRUE).addOrCondition(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS, RFConstants.historyStatus.DISCARDED);
  gr.orderByDesc(RFConstants.fields.SYS_CREATED_ON);
  gr.query();
  var history = [];
  var ruleEligibility = {};
  if (gr.hasNext()) {
      var targetGr = new GlideRecord(tableName);
      var isValid = targetGr.isValid() && targetGr.get(sysId);
      if (!isValid) {
          return new RFExceptionManager("INVALID_RECORD").getJSON();
      }
  }
  while (gr.next()) {
      var expID = gr.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RECOMMENDATION_EXPERIENCE);
      var exp = new RFExperienceService(expID);
      var ruleSysId = exp.getRuleSysId();
      if (!(ruleEligibility.hasOwnProperty(ruleSysId))) {
          var rule = exp.getRule();
          ruleEligibility[ruleSysId] = RFHistoryService._isRuleEligible(rule);
      }
      if (!ruleEligibility[ruleSysId]) {
          continue;
      }
      var ruleOutputsObjectDetails = RFActionService.createObjectFromRuleOutputs(gr.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_RULE_OUTPUT));
      if (!ruleOutputsObjectDetails.isAccessible) {
          continue;
      }
      var evaluationOutputs = ruleOutputsObjectDetails.ruleOutputsObject;
      var isDiscarded = gr.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_HISTORY_STATUS) == RFConstants.historyStatus.DISCARDED;
      var expDetails = exp.getDetails(targetGr, evaluationOutputs, true, {
          discarded: isDiscarded
      });
      if (expDetails) {
          history.push(expDetails);
      }
  }
  return {
      "recommendations": history
  };
};

RFHistoryService._isRuleEligible = function(rule) {
  return rule.hasValidRecord() && rule.isCurrentUserEligible();
};

RFHistoryService.prototype = {
  tableName: RFConstants.tables.SN_RF_RECOMENDATION_HISTORY,

  initialize: function(grOrSysId) {
      if (grOrSysId && grOrSysId.sys_class_name == this.tableName) {
          this.currentRecord = grOrSysId;
      } else if (grOrSysId) {
          var historyGr = new GlideRecord(this.tableName);
          if (historyGr.get(grOrSysId)) {
              this.currentRecord = historyGr;
          }
      }
  },

  type: 'RFHistoryService'
};

Sys ID

2b4e6495c740011020dab6c427c260de

Offical Documentation

Official Docs: