Name
sn_nb_action.NextBestActionUtil
Description
A class for utility functions to be used across the Recommended action.
Script
var NextBestActionUtil = Class.create();
NextBestActionUtil.prototype = {
initialize: function() {},
type: 'NextBestActionUtil'
};
NextBestActionUtil._log = new global.GSLog(sn_nb_action.Constants.PROP_LOG_LEVEL, 'NextBestActionUtil');
NextBestActionUtil.getExtensions = function(epName) {
try {
var ep = new GlideScriptedExtensionPoint().getExtensions(epName);
if (ep.length > 0)
return ep;
} catch (ex) {
NextBestActionUtil._log.error("Error fetching extensions - " + ex);
}
return [];
};
NextBestActionUtil.loadExtensions = function(epName) {
var extensions = NextBestActionUtil.getExtensions(epName);
var extnMap = {};
for (var i = 0; i < extensions.length; i++) {
try {
var extInstance = extensions[i];
if (extInstance && typeof extInstance.getId === "function") {
var extId = extInstance.getId();
if (NextBestActionUtil.isValidString(extId))
extnMap[extId] = extInstance;
}
} catch (ex) {
NextBestActionUtil._log.error("Error loading extension - " + ex);
}
}
return extnMap;
};
NextBestActionUtil.getRuleTypeHandler = function(ruleType) {
if (!NextBestActionUtil.ruleHandlers)
NextBestActionUtil.ruleHandlers = NextBestActionUtil.loadExtensions(sn_nb_action.Constants.EXT_RULE_TYPE_FACTORY);
if (NextBestActionUtil.ruleHandlers.hasOwnProperty(ruleType))
return NextBestActionUtil.ruleHandlers[ruleType];
return false;
};
NextBestActionUtil.getActionTypeHandler = function(actionTypeRecord) {
if (NextBestActionUtil.isValidRecord(actionTypeRecord)) {
var actionTableName = actionTypeRecord.getValue(sn_nb_action.Constants.COL_TABLE_NAME);
return NextBestActionUtil.getActionTypeHandlerForTable(actionTableName);
}
return false;
};
NextBestActionUtil.getActionTypeHandlerForTable = function(actionTableName) {
if (NextBestActionUtil.isValidString(actionTableName)) {
if (!NextBestActionUtil.actionHandlers)
NextBestActionUtil.actionHandlers = NextBestActionUtil.loadExtensions(sn_nb_action.Constants.EXT_ACTION_TYPE_FACTORY);
if (NextBestActionUtil.actionHandlers.hasOwnProperty(actionTableName))
return NextBestActionUtil.actionHandlers[actionTableName];
}
return false;
};
NextBestActionUtil.getScriptingGeneratorForScript = function(scriptGr) {
if (NextBestActionUtil.isValidRecord(scriptGr)) {
if (!NextBestActionUtil.scriptingGenerators)
NextBestActionUtil.scriptingGenerators = NextBestActionUtil.loadExtensions(Constants.EXT_SCRIPTING_GENERATOR_FACTORY);
var apiName = scriptGr.getValue(sn_nb_action.Constants.COL_API_NAME);
if (NextBestActionUtil.scriptingGenerators.hasOwnProperty(apiName))
return NextBestActionUtil.scriptingGenerators[apiName];
}
return false;
};
NextBestActionUtil.getGeneratorTypeHandler = function(generatorTypeSysId) {
if (NextBestActionUtil.isValidString(generatorTypeSysId)) {
if (!NextBestActionUtil.generatorHandlers)
NextBestActionUtil.generatorHandlers = NextBestActionUtil.loadExtensions(Constants.EXT_GENERATOR_TYPE_FACTORY);
if (NextBestActionUtil.generatorHandlers.hasOwnProperty(generatorTypeSysId))
return NextBestActionUtil.generatorHandlers[generatorTypeSysId];
}
return false;
};
/* Returns an array containing values of all attributes of the given object. If value in an object
* is itself of array type, then the array values are also pushed to resulting array
*/
NextBestActionUtil.getObjectValues = function(obj) {
var values = [];
for (var k in obj) {
var val = obj[k];
if (Array.isArray(val) && val && val.length > 0) {
for (var i = 0; i < val.length; i++)
values.push(val[i]);
} else if (!Array.isArray(val) && val && val != null)
values.push(val);
}
if (values.length > 0)
return values;
return false;
};
NextBestActionUtil.getGlideVarInputs = function(record, field) {
var inputsObject = new Object();
for (var input in record[field]) {
if (input != "sys_meta" && input != "sys_id") {
if (!record[field][input]) {
inputsObject[input] = record[field][input];
continue;
}
var inputRecord = record[field][input].getRefRecord();
if (gs.nil(inputRecord))
inputsObject[input] = record[field][input];
else
inputsObject[input] = inputRecord;
}
}
return inputsObject;
};
NextBestActionUtil.setGlideVarInputs = function(record, field, inputsObject) {
for (var input in inputsObject) {
if (sn_nb_action.NextBestActionUtil.isValidRecord(inputsObject[input]))
record[field][input] = inputsObject[input].getUniqueValue();
else
record[field][input] = inputsObject[input];
}
return;
};
// Searches for duplicate action detail object in a given array
NextBestActionUtil.getDuplicateActionDetail = function(actionDetailObjArr, newActionDetailObj) {
var actionTypeTable = newActionDetailObj.getActionTypeTable();
var actionHandler = sn_nb_action.NextBestActionUtil.getActionTypeHandlerForTable(actionTypeTable);
if (actionHandler) {
try {
if (typeof actionHandler.getDuplicate === "function") {
return actionHandler.getDuplicate(actionDetailObjArr, newActionDetailObj);
}
} catch (ex) {
this._log.error("Failed to get duplicate of action " + newActionDetailObj.getAction());
}
} else
this._log.error("Could not find implementation for action type for action table " + actionTypeTable);
return false;
};
NextBestActionUtil.isValidRecord = function(record) {
return record && typeof record.isValidRecord === 'function' && record.isValidRecord();
};
NextBestActionUtil.isValidString = function(str) {
return str && !gs.nil(str);
};
NextBestActionUtil.isEmptyObject = function(obj) {
return (obj && Object.keys(obj).length === 0 && obj.constructor === Object);
};
NextBestActionUtil.isValidContextState = function(state) {
return NextBestActionUtil.isValidString(state) && sn_nb_action.Constants.STATES_CONTEXT.indexOf(state.toLowerCase()) != -1;
};
NextBestActionUtil.isValidActionState = function(state) {
return NextBestActionUtil.isValidString(state) && sn_nb_action.Constants.STATES_ACTION_DETAIL.indexOf(state.toLowerCase()) != -1;
};
NextBestActionUtil.getActionService = function() {
return new sn_nb_action.ActionService();
};
NextBestActionUtil.getRuleService = function() {
return new sn_nb_action.RuleService();
};
NextBestActionUtil.getNextBestActionDAO = function() {
return new sn_nb_action.NextBestActionDAO();
};
NextBestActionUtil.getGroupingService = function(ruleContext) {
if (NextBestActionUtil.isValidRecord(ruleContext)) {
if (!NextBestActionUtil.groupStrategies)
NextBestActionUtil.groupStrategies = NextBestActionUtil.loadExtensions(sn_nb_action.Constants.EXT_GROUPING_STRATEGY);
var strategyId = ruleContext.getValue(sn_nb_action.Constants.COL_GROUPING_STRATEGY);
if (NextBestActionUtil.groupStrategies.hasOwnProperty(strategyId))
return NextBestActionUtil.groupStrategies[strategyId];
}
return false;
};
NextBestActionUtil.getCountOfDefaultGroupPerContext = function(ruleContextSysId, currentGroupSysId){
var ga = new GlideAggregate(sn_nb_action.Constants.TBL_CONTEXT_GROUP);
ga.addQuery("context", ruleContextSysId);
ga.addQuery("sys_id", "!=", currentGroupSysId)
ga.addQuery("active", true);
ga.addQuery("default", true);
ga.addAggregate("COUNT", "sys_id");
ga.groupBy("context");
ga.query();
var count = 0;
if(ga.next()){
count = ga.getAggregate("COUNT", "sys_id");
}
return count;
},
NextBestActionUtil.addToSchema = function(schema, name, label, type, referenceTable) {
var schemaElement = {
'name': name,
'label': label,
'type': type
};
if (type == Constants.TYPE_REFERENCE) {
schemaElement[Constants.pillPickerVars.REFERENCE_TABLE] = referenceTable;
}
schema.push(schemaElement);
};
NextBestActionUtil.getInstancesForExtensionPoint = function(extensionPoint) {
var implementations = [];
var instanceGr = new GlideRecord(Constants.TBL_EXTENSION_INSTANCE);
instanceGr.addActiveQuery();
instanceGr.addQuery(Constants.COL_POINT, extensionPoint);
instanceGr.addQuery('script_include.active', 'true');
instanceGr.query();
while (instanceGr.next()) {
var scriptInclude = instanceGr.getValue(Constants.COL_SCRIPT_INCLUDE);
if (scriptInclude) {
implementations.push(scriptInclude);
}
}
return implementations;
};
NextBestActionUtil.getConsolidateActions = function() {
return new sn_nb_action.ConsolidateActions();
};
NextBestActionUtil.getMaxAge = function(contextRecord) {
var raContext = new GlideRecord(sn_nb_action.Constants.TBL_RULE_CONTEXT);
raContext.addQuery(sn_nb_action.Constants.COL_CONTEXT, contextRecord.getValue(sn_nb_action.Constants.COL_CONTEXT_TABLE));
raContext.setLimit(1);
raContext.query();
var refreshInterval = sn_nb_action.Constants.DEFAULT_REFRESH_INTERVAL;
if (raContext.next() && !gs.nil(raContext.getValue(sn_nb_action.Constants.COL_REFRESH_INTERVAL))) {
refreshInterval = ((new GlideDateTime(raContext.getValue(sn_nb_action.Constants.COL_REFRESH_INTERVAL)).getNumericValue()) / 1000);
if (refreshInterval < sn_nb_action.Constants.MINIMUM_REFRESH_INTERVAL)
refreshInterval = sn_nb_action.Constants.MINIMUM_REFRESH_INTERVAL;
}
var maxAge = new GlideDateTime();
maxAge.addSeconds(refreshInterval);
return maxAge;
};
NextBestActionUtil.getFieldReferenceTable = function(table, field) {
if (table && field) {
var tableGr = new GlideRecord(table);
var referenceField = tableGr.isValid() && tableGr.getElement(field);
if (referenceField == null || referenceField.getED().getInternalType() != Constants.TYPE_REFERENCE) {
return;
}
return referenceField.getReferenceTable();
}
};
NextBestActionUtil.getHashValue = function(contextSysId, actionSysId, actionInputs) {
var hash = '';
hash = hash + contextSysId + actionSysId;
if (!NextBestActionUtil.isEmptyObject(actionInputs)) {
for (var input in actionInputs) {
var inputValue;
if (NextBestActionUtil.isValidRecord(actionInputs[input]))
inputValue = actionInputs[input].getUniqueValue();
else
inputValue = actionInputs[input];
hash = hash + input + inputValue;
}
}
var digest = new GlideDigest();
var hashId = digest.getSHA1Base64(hash);
return hashId;
};
Sys ID
f779943d3bba1010c24e870044efc44f