Name
global.SLACacheManager
Description
No description available
Script
var SLACacheManager = Class.create();
SLACacheManager.SLA_DEF_TABLES_CACHE = "com.snc.sla.def_tables_cache";
SLACacheManager.SLA_BREAKDOWN_DEF_CACHE = "com.snc.sla.breakdown_def_cache";
SLACacheManager.SLA_DEF_SLA_BREAKDOWN_CACHE = "com.snc.sla.sla_def_sla_breakdown_cache";
SLACacheManager.prototype = {
_GLOBAL: "global",
initialize: function() {
this._initPrivateCacheable(SLACacheManager.SLA_DEF_TABLES_CACHE);
this._initPrivateCacheable(SLACacheManager.SLA_BREAKDOWN_DEF_CACHE);
this._initPrivateCacheable(SLACacheManager.SLA_DEF_SLA_BREAKDOWN_CACHE);
},
flushDefinitionTables: function() {
GlideCacheManager.flush(SLACacheManager.SLA_DEF_TABLES_CACHE);
},
hasDefinitionForRecord: function(gr) {
if (!gr || !gr.isValid())
return false;
var key = this._buildTableKey(gr.getRecordClassName(), gr.getValue("sys_domain"));
var hasDefs = GlideCacheManager.get(SLACacheManager.SLA_DEF_TABLES_CACHE, key);
if (hasDefs === null) {
hasDefs = this.getDefinitionsForRecord(gr);
GlideCacheManager.put(SLACacheManager.SLA_DEF_TABLES_CACHE, key, hasDefs);
}
return hasDefs;
},
getDefinitionsForRecord: function(gr) {
var slaDefGr = new GlideRecord("contract_sla");
slaDefGr.addActiveQuery();
slaDefGr.addQuery("collection", gr.getRecordClassName());
slaDefGr.addDomainQuery(gr);
// Don't let Business Rules mess around with this query...it should always be able to read contract_sla to correctly populate the cache.
slaDefGr.setWorkflow(false);
/* only use "setLimit" if process separation is disabled for domains - there's potential for a query with setLimit to return
no data due to overriden records being removed from the query results */
if (!GlideDomainSupport.isProcessSeparationEnabled())
slaDefGr.setLimit(1);
slaDefGr.query();
return slaDefGr.hasNext();
},
getBreakdownDefinitionsForSLA: function(slaId) {
var breakdownDefs = {};
if (!GlidePluginManager.isActive("com.snc.sla.breakdowns"))
return breakdownDefs;
if (!slaId)
return breakdownDefs;
// First get the ids of the breakdown definitions linked to the SLA Definition
var breakdownIds = this._getBreakdownIdsForSLA(slaId);
if (!breakdownIds || breakdownIds.length === 0)
return breakdownDefs;
var breakdownId;
var breakdownDef;
var uncachedBreakdownIds = [];
// Where possible get the breakdown definitions from the cache
for (var i = 0, l = breakdownIds.length; i < l; i++) {
breakdownId = breakdownIds[i];
/* We need this test as an earlier version of the caching stored actual Javascript objects instead of a
a JSON stringified copy of the object */
breakdownDef = GlideCacheManager.get(SLACacheManager.SLA_BREAKDOWN_DEF_CACHE, breakdownId);
if (breakdownDef instanceof String)
breakdownDef = JSON.parse(breakdownDef);
if (breakdownDef !== null)
breakdownDefs[breakdownId] = breakdownDef;
else
uncachedBreakdownIds.push(breakdownId);
}
// For the breakdown defs we need that weren't in the cache, get them from the DB
var queriedBreakdownDefs = this._getBreakdownDefinitionsByIds(uncachedBreakdownIds);
uncachedBreakdownIds = Object.keys(queriedBreakdownDefs);
// And then add them into the cache and the object we return
for (var j = 0, n = uncachedBreakdownIds.length; j < n; j++) {
breakdownId = uncachedBreakdownIds[j];
GlideCacheManager.put(SLACacheManager.SLA_BREAKDOWN_DEF_CACHE, breakdownId, JSON.stringify(queriedBreakdownDefs[breakdownId]));
breakdownDefs[breakdownId] = queriedBreakdownDefs[breakdownId];
}
return breakdownDefs;
},
_getBreakdownIdsForSLA: function(slaId) {
var breakdownIds = [];
if (!slaId)
return breakdownIds;
breakdownIds = GlideCacheManager.get(SLACacheManager.SLA_DEF_SLA_BREAKDOWN_CACHE, slaId);
/* We need this test as an earlier version of the caching stored actual Javascript arrays instead of a
a JSON stringified copy of the array */
if (breakdownIds instanceof String)
breakdownIds = JSON.parse(breakdownIds);
if (breakdownIds === null) {
breakdownIds = new SLABreakdownUtils().getBreakdownDefIdsForSLA(slaId);
if (breakdownIds !== null)
GlideCacheManager.put(SLACacheManager.SLA_DEF_SLA_BREAKDOWN_CACHE, slaId, JSON.stringify(breakdownIds));
}
return breakdownIds;
},
_getBreakdownDefinitionsByIds: function(breakdownIds) {
var breakdownDefinitionsData = {};
if (!breakdownIds || breakdownIds.lengh === 0)
return breakdownDefinitionsData;
var breakdownFieldGr = new GlideRecord(sn_sla_brkdwn.SLABreakdown.SLA_BREAKDOWN_DEFINITION_FIELD);
breakdownFieldGr.addQuery("sla_breakdown_definition", breakdownIds);
breakdownFieldGr.addQuery("sla_breakdown_definition.active", "true");
breakdownFieldGr.orderBy("sla_breakdown_definition");
breakdownFieldGr.query();
var breakdownDefinitionId;
var breakdownTableName;
var taskTableName;
var sourceFieldName;
var breakdownFieldName;
var td;
while (breakdownFieldGr.next()) {
breakdownTableName = breakdownFieldGr[sn_sla_brkdwn.SLABreakdown.SLA_BREAKDOWN_DEFINITION].sla_breakdown_table + "";
if (!breakdownTableName)
continue;
td = GlideTableDescriptor.get(breakdownTableName);
if (!td.isValid())
continue;
breakdownFieldName = breakdownFieldGr.getValue("breakdown_field_name");
if (!td.isValidField(breakdownFieldName))
continue;
taskTableName = breakdownFieldGr[sn_sla_brkdwn.SLABreakdown.SLA_BREAKDOWN_DEFINITION].task_table + "";
if (!taskTableName)
continue;
td = GlideTableDescriptor.get(taskTableName);
if (!td.isValid())
continue;
sourceFieldName = breakdownFieldGr.getValue("source_field_name");
if (!td.isValidField(sourceFieldName))
continue;
breakdownDefinitionId = breakdownFieldGr.getValue("sla_breakdown_definition");
if (!breakdownDefinitionsData[breakdownDefinitionId])
breakdownDefinitionsData[breakdownDefinitionId] = {taskTable: taskTableName,
breakdownTable: breakdownTableName,
breakdownFields: []};
breakdownDefinitionsData[breakdownDefinitionId].breakdownFields.push({sourceFieldName: sourceFieldName,
breakdownFieldName: breakdownFieldName});
}
return breakdownDefinitionsData;
},
_initPrivateCacheable: function(name) {
if (!name)
return;
if (GlideCacheManager.get(name, "_created_") != null)
return;
GlideCacheManager.addPrivateCacheable(name);
GlideCacheManager.put(name, "_created_", new GlideDateTime().getNumericValue());
},
_buildTableKey: function(table, domain){
if (!domain)
domain = this._GLOBAL;
return table + "_" + domain;
},
type: "SLACacheManager"
};
SLACacheManager.flushDefinitionTables = function() {
GlideCacheManager.flush(SLACacheManager.SLA_DEF_TABLES_CACHE);
};
SLACacheManager.flushBreakdownDefinitions = function() {
GlideCacheManager.flush(SLACacheManager.SLA_BREAKDOWN_DEF_CACHE);
};
SLACacheManager.flushSLADefSLABreakdowns = function() {
GlideCacheManager.flush(SLACacheManager.SLA_DEF_SLA_BREAKDOWN_CACHE);
};
Sys ID
a62b8ec0cb200300dff9b9c0c24c9ccd