Name

sn_rf.RFRuleService

Description

Class for sn_rf_recommendation_rule table utility functions.

Script

var RFRuleService = Class.create();

RFRuleService.sortComparator = function() {
  return function(rule1, rule2) {
      var prioritize = RFConstants.fields.SN_RF_RECOMMENDATION_RULE_PRIORITIZE;
      var order = RFConstants.fields.SN_RF_RECOMMENDATION_RULE_ORDER;
      var usage = RFConstants.USAGE;
      if (rule1[prioritize] && rule2[prioritize]) {
          return rule1[order] - rule2[order];
      } else if (rule1[prioritize]) {
          return -1;
      } else if (rule2[prioritize]) {
          return 1;
      } else if (rule1[usage] == rule2[usage]) {
          return rule1[order] - rule2[order];
      } else {
          return rule2[usage] - rule1[usage];
      }
  };
};

RFRuleService.isActivePropertyCheck = function(sysId) {
  var fieldName = RFConstants.fields.SN_RF_RECOMMENDATION_RULE_ACTIVE;
  var configurationPropertyName = RFUtils.getConfigurationPropertyName(RFConstants.tables.SN_RF_RECOMMENDATION_RULE, fieldName, sysId);
  var propValue = gs.getProperty(configurationPropertyName, RFConstants.configurationPropertyVars.PROPERTY_NOT_EXISTS);
  if (propValue != RFConstants.configurationPropertyVars.PROPERTY_NOT_EXISTS) {
      return propValue == 'true';
  }
};

RFRuleService.prototype = {
  tableName: RFConstants.tables.SN_RF_RECOMMENDATION_RULE,

  initialize: function(grOrSysId) {
      this.rfLogger = new RFLogger("RFRuleService");
      if (grOrSysId && grOrSysId.sys_class_name == this.tableName) {
          this.currentRecord = grOrSysId;
      } else if (grOrSysId) {
          var gr = new GlideRecord(this.tableName);
          if (gr.get(grOrSysId)) {
              this.currentRecord = gr;
          }
      }
  },

  hasValidRecord: function() {
      return this.currentRecord && this.currentRecord.sys_class_name == this.tableName;
  },

  getTable: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_TABLE);
  },

  getEvaluationTypeSysId: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_EVALUATION_TYPE);
  },

  getEvaluationType: function() {
      var evaluationTypeId = this.getEvaluationTypeSysId();
      if (evaluationTypeId) {
          var evaluationType = new RFEvaluationTypeService(evaluationTypeId);
          if (evaluationType.hasValidRecord()) {
              return evaluationType;
          }
      }
  },

  getEvaluationTypeInputs: function() {
      var inputs = {};
      var evaluationTypeSysId = this.getEvaluationTypeSysId();
      var evaluationTypeInputs = RFEvaluationTypeInputService.getByEvaluationTypeSysId(evaluationTypeSysId);
      for (var i = 0; i < evaluationTypeInputs.length; i++) {
          var inputKey = evaluationTypeInputs[i].getName();
          var inputVal = this.currentRecord[RFConstants.fields.SN_RF_RECOMMENDATION_RULE_EVALUATION_TYPE_INPUT][inputKey];
          inputs[inputKey] = inputVal.toString();
      }
      return inputs;
  },

  getReEvaluationFields: function() {
      var fields = [];
      var dbValue = this.currentRecord[RFConstants.fields.SN_RF_RECOMMENDATION_RULE_RE_EVALUATION_FIELDS];
      if (dbValue) {
          fields = dbValue.split(',');
      }
      return fields;
  },

  isActive: function() {
      var fieldName = RFConstants.fields.SN_RF_RECOMMENDATION_RULE_ACTIVE;
      var configurationPropertyName = RFUtils.getConfigurationPropertyName(this.tableName, fieldName, this.getSysID());
      return gs.getProperty(configurationPropertyName, this.currentRecord[fieldName]) == 'true';
  },

  isPrioritized: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_PRIORITIZE) == '1';
  },

  getDoesNotAppliesToUserCriteria: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_DOES_NOT_APPLIES_TO);
  },

  getAppliesToUserCriteria: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_APPLIES_TO);
  },

  getConditionBuilder: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_CONDITION_BUILDER);
  },

  getTitle: function() {
      return this.currentRecord.getDisplayValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_TITLE) || "";
  },

  getDescription: function() {
      return this.currentRecord.getDisplayValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_DESCRIPTION) || "";
  },

  getOrder: function() {
      var order = RFConstants.DEFAULT_ORDER;
      var number = this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_ORDER);
      if (number) {
          order = Number(number);
      }
      return order;
  },

  getSysID: function() {
      return this.currentRecord.getValue(RFConstants.fields.SN_RF_RECOMMENDATION_RULE_SYS_ID);
  },

  getExperiences: function(experienceTypes) {
      return RFExperienceService.getByRule(this, experienceTypes);
  },

  evaluateRule: function(contextRecord) {
      var evaluationType = this.getEvaluationType();
      return evaluationType && evaluationType.getEvaluationTypeOutput(this, contextRecord);
  },

  isCurrentUserEligible: function() {
      var doesNotAppliesToUserCriteria = this.getDoesNotAppliesToUserCriteria();
      if (doesNotAppliesToUserCriteria && RFUtils.evaluateUserCriteria(doesNotAppliesToUserCriteria)) {
          return false;
      }
      var appliesToUserCriteria = this.getAppliesToUserCriteria();
      if (appliesToUserCriteria && !RFUtils.evaluateUserCriteria(appliesToUserCriteria)) {
          return false;
      }
      return true;
  },

  getDetails: function(contextRecord, experienceTypes) {
      try {
          if (!this.isActive()) {
              this.rfLogger.logDebug('Rule ' + this.getSysID() + ' is inactive');
              return;
          }

          var conditions = this.getConditionBuilder();
          if (conditions && !GlideFilter.checkRecord(contextRecord, conditions)) {
              this.rfLogger.logDebug('Context record ' + contextRecord.sys_id + ' did not qualify condition for rule ' + this.getSysID() + ' on table ' + this.getTable());
              return;
          }

          if (!this.isCurrentUserEligible()) {
              this.rfLogger.logDebug('Current user ' + gs.getUserID() + ' did not qualify user criteria for rule ' + this.getSysID());
              return;
          }

          var outputs = this.evaluateRule(contextRecord);
          if (!outputs || !outputs.evaluationOutputs || RFConstants.SUCCESS !== outputs.status ||
              outputs.evaluationOutputs.length == 0) {
              this.rfLogger.logDebug('No output received from the evaluator script of rule ' + this.getSysID());
              return;
          }

          var experiencesDetails = this._getExperiencesDetails(contextRecord, outputs.evaluationOutputs, experienceTypes);
          if (experiencesDetails.length == 0) {
              this.rfLogger.logDebug('No experience details found for rule ' + this.getSysID());
              return;
          }

          return {
              'ruleSysId': this.getSysID(),
              'title': this.getTitle(),
              'description': this.getDescription(),
              'order': this.getOrder(),
              'prioritize': this.isPrioritized(),
              'usage': RFHistoryService.getCountForRuleId(this.getSysID()),
              'triggerFields': this.getReEvaluationFields(),
              'recommendations': experiencesDetails
          };
      } catch (e) {
          this.rfLogger.logError('Error occurred while executing getDetails for Rule ' + this.getSysID() + '. Error: ' + e);
      }
  },

  _getExperiencesDetails: function(contextRecord, evaluationOutputs, experienceTypes) {
      var experiencesDetails = [];
      var experiences = this.getExperiences(experienceTypes);
      for (var experienceIdx = 0; experienceIdx < experiences.length; experienceIdx++) {
          for (var evaluationOuptutIdx = 0; evaluationOuptutIdx < evaluationOutputs.length; evaluationOuptutIdx++) {
              var details = experiences[experienceIdx].getDetails(contextRecord, evaluationOutputs[evaluationOuptutIdx]);
              if (details) {
                  experiencesDetails.push(details);
              }
          }
      }
      return experiencesDetails;
  },

  type: 'RFRuleService'
};

Sys ID

04e76a9b53433010e530ddeeff7b1290

Offical Documentation

Official Docs: