Name
global.EventRuleUtil
Description
No description available
Script
var EventRuleUtil = Class.create();
EventRuleUtil.prototype = {
initialize: function() {
this.FIELD_MAPPING_RUN_AFTER_BINDING_ENABLED_PROPERTY = "evt_mgmt.field_mapping_run_after_binding_enabled";
this.FIELD_MAPPING_RUN_AFTER_BINDING_ENABLED_DEFAULT_VALUE = "true";
this.FIELD_MAPPING_FROM_FIELD_CMDB_CI_PROPERTY = "evt_mgmt.field_mapping_alert_cmdb_ci_prefix";
this.FIELD_MAPPING_FROM_FIELD_CMDB_CI_DEFAULT_VALUE = "alert_cmdb_ci.";
this.FIELD_MAPPING_FROM_FIELD_CMDB_KEY_VALUE_PROPERTY = "evt_mgmt.field_mapping_alert_cmdb_ci_key_prefix";
this.FIELD_MAPPING_FROM_FIELD_CMDB_KEY_VALUE_DEFAULT_VALUE = "alert_cmdb_ci_key.";
this.FIELD_MAPPING_FROM_FIELD_ADD_INFO_VALUE_PROPERTY = "evt_mgmt.add_info_prefix";
this.FIELD_MAPPING_FROM_FIELD_ADD_INFO_DEFAULT_VALUE = "additional_info.";
this.SUPPORTED_FIELD_MAPPING_TYPES_WITH_RUN_AFTER_BINDING = [
1, // Single field
3, // Copy value
4, // Single field with regex
6, // Copy groups from regex
7, // Script
8, // Map field from reference table
];
},
parseXMLFromTable: function() {
var xmlGr = new GlideRecord('em_rule_xml');
xmlGr.addQuery();
xmlGr.query();
var resultCount = {
mapRule: 0,
mapRuleFailed: 0,
matchRule: 0,
matchRuleFailed: 0
};
while (xmlGr.next()) {
this.parseXML(xmlGr.rule_xml, xmlGr.name, resultCount);
}
gs.message(gs.getMessage("Transform rules: {0} imported successfully, {1} failed.", [resultCount.matchRule, resultCount.matchRuleFailed]));
gs.message(gs.getMessage("Match rules: {0} imported successfully, {1} failed.", [resultCount.mapRule, resultCount.mapRuleFailed]));
},
parseXML: function(rule_xml, file_name, resultCount) {
var xmlDoc = new XMLDocument(rule_xml);
//determine whether it is matching rule or mapping rule
var nodelist = xmlDoc.getNodes("//fieldMappingRule");
//it is a mapping rule
if (nodelist.getLength() == 1) {
this.parseMappingRule(xmlDoc, file_name, resultCount);
}
//it is a matching rule
else {
var matchnodelist = xmlDoc.getNodes("//matchRule");
//it is a matching rule
if (matchnodelist.getLength() >= 1) {
var res = this.parseMatchingRule(xmlDoc);
if (res) {
resultCount.matchRule++;
} else {
resultCount.matchRuleFailed++;
resultCount.success = false;
}
} else {
gs.addErrorMessage(gs.getMessage('XML malformed, or XML structure incorrect.'));
resultCount.success = false;
}
}
},
parseMappingRule: function(xmlDoc, file_name, resultCount) {
var nodelist = {};
var node = {};
var xmlUtil = GlideXMLUtil;
//get name - note: for field mapping rules name may be replaced below.
var name = file_name;
//get ems
node = xmlDoc.getNode("//fieldMappingRule/ems");
var source = xmlUtil.getText(node);
//get constant mapping
nodelist = xmlDoc.getNodes("//fieldMappingRule/constantMappings/entry");
var k = nodelist.getLength();
nodelist = xmlDoc.getNodes("//fieldMappingRule/constantMappings/entry/*");
for (var i = 0; i < k; i++) {
var toField = xmlUtil.getText(nodelist.item(2 * i));
var value = xmlUtil.getText(nodelist.item(2 * i + 1));
if (toField == 'resolutionState' && value == 'NEW')
continue;
toField = this.translateField(toField);
if (toField == 'severity')
value = this.translateSeverity(value);
if (toField == 'resolution_state')
value = this.translateState(value);
name = source + '-' + value;
var res = this.insertConstantMapping(name, source, toField, value);
if (res) {
resultCount.mapRule++;
} else {
resultCount.mapRuleFailed++;
resultCount.success = false;
}
}
//get single field mapping
nodelist = xmlDoc.getNodes("//fieldMappingRule/singleFieldMappings");
var x = nodelist.getLength();
for (var i = 0; i < x; i++) {
var childs = nodelist.item(i).getChildNodes();
var fromField = '';
var toField = '';
var mapping_id = '';
for (var j = 0; j < childs.getLength(); j++) {
if (childs.item(j).getNodeName() == 'fromField') {
fromField = xmlUtil.getText(childs.item(j));
fromField = this.translateField(fromField);
name = source + '-' + fromField;
}
if (childs.item(j).getNodeName() == 'toField') {
toField = xmlUtil.getText(childs.item(j));
toField = this.translateField(toField);
mapping_id = this.insertSingleFieldMapping(name, source, fromField, toField);
if (mapping_id) {
resultCount.mapRule++;
} else {
resultCount.mapRuleFailed++;
resultCount.success = false;
}
}
if (childs.item(j).getNodeName() == 'valueMappings') {
var entry = childs.item(j).getChildNodes();
for (var k = 0; k < entry.getLength(); k++) {
if (entry.item(k).getNodeName() == 'entry') {
var key = xmlUtil.getText(entry.item(k).getChildNodes().item(1));
var value = xmlUtil.getText(entry.item(k).getChildNodes().item(3));
if (toField == 'severity')
value = this.translateSeverity(value);
if (toField == 'resolution_state')
value = this.translateState(value);
if (fromField == 'severity')
key = this.translateSeverity(key);
if (fromField == 'resolution_state')
key = this.translateState(key);
this.insertEventMappingPair(mapping_id, key, value);
}
}
}
}
}
resultCount.success = (resultCount.mapRule > 0 || resultCount.matchRule > 0) &&
resultCount.mapRuleFailed == 0 && resultCount.matchRuleFailed == 0;
},
parseMatchingRule: function(xmlDoc) {
var nodelist = {};
var node = {};
var xmlUtil = GlideXMLUtil;
//get ems
node = xmlDoc.getNode("//matchRule/ems");
var source = xmlUtil.getText(node);
//get order
node = xmlDoc.getNode("//matchRule/ruleOrder");
var ruleOrder = xmlUtil.getText(node);
//get name
node = xmlDoc.getNode("//matchRule/name");
var name = xmlUtil.getText(node);
//get ignore
node = xmlDoc.getNode("//matchRule/ignore");
var ignore = xmlUtil.getText(node);
//get ciTypeName
ciTypeName = xmlDoc.getNode("//matchRule/ciTypeName");
var ciTypeName = xmlUtil.getText(ciTypeName);
//get ciTypeName
swId = xmlDoc.getNode("//matchRule/id");
var swId = xmlUtil.getText(swId);
var match_id = this.insertMatchRule(swId, name, source, ignore, parseInt(ruleOrder) + 100, ciTypeName);
if (match_id == null)
return false;
//get field composition
nodelist = xmlDoc.getNodes("//matchRule/fieldCompositions");
var k = nodelist.getLength();
for (var i = 0; i < k; i++) {
var childs = nodelist.item(i).getChildNodes();
for (var a = 0; a < childs.getLength(); a++) {
if (childs.item(a).getNodeName() == 'composingFields') {
var composingFields = xmlUtil.getText(childs.item(a));
}
if (childs.item(a).getNodeName() == 'fieldName') {
var field = xmlUtil.getText(childs.item(a));
}
}
field = this.translateField(field);
if (field == 'severity')
composingFields = this.translateSeverity(composingFields);
else if (field == 'resolution_state')
composingFields = this.translateState(composingFields);
else
composingFields = this.translateComposition(composingFields);
this.insertComposeField(match_id, field, composingFields);
}
//get matchFields
nodelist = xmlDoc.getNodes("//matchRule/matchFields");
var k = nodelist.getLength();
for (var i = 0; i < k; i++) {
var childNodes = nodelist.item(i).getChildNodes();
var hasRegex = false;
for (var j = 0; j < childNodes.getLength(); j++) {
if (childNodes.item(j).getNodeName() == 'regex') {
hasRegex = true;
break;
}
}
//we remove this, because we wan't also to save exact match fields
//if (!hasRegex)
// continue;
var hasGroupMapping = false;
var groupMapping = '';
for (var j = 0; j < childNodes.getLength(); j++) {
if (childNodes.item(j).getNodeName() == 'field') {
var field = xmlUtil.getText(childNodes.item(j));
}
if (childNodes.item(j).getNodeName() == 'regex') {
var regex = xmlUtil.getText(childNodes.item(j));
}
if (childNodes.item(j).getNodeName() == 'groupMappings') {
var mapping = this.translateField(xmlUtil.getText(childNodes.item(j)));
if (!hasGroupMapping) {
groupMapping = mapping;
hasGroupMapping = true;
} else {
groupMapping += ',' + mapping;
}
}
if (childNodes.item(j).getNodeName() == 'example') {
//if the field has no regex part- use the example field
if (!hasRegex) {
var regex = xmlUtil.getText(childNodes.item(j));
}
}
}
field = this.translateField(field);
this.insertMatchField(match_id, field, groupMapping, regex);
}
return true;
},
insertConstantMapping: function(name, source, toField, value) {
var mappingRule = new GlideRecord('em_mapping_rule');
mappingRule.addQuery('name', name);
mappingRule.query();
if (mappingRule.hasNext()) {
var msg = gs.getMessage('A mapping rule named "{0}" already exists, rule not imported.', [name]);
gs.addErrorMessage(msg);
return false;
}
mappingRule.initialize();
mappingRule.name = name;
mappingRule.event_class = source;
mappingRule.mapping_type = '2'; //constant type
mappingRule.to_field = toField;
mappingRule.value = value;
return mappingRule.insert();
},
insertSingleFieldMapping: function(name, source, fromField, toField) {
var mappingRule = new GlideRecord('em_mapping_rule');
mappingRule.addQuery('name', name);
mappingRule.query();
if (mappingRule.hasNext()) {
var msg = gs.getMessage('A mapping rule named "{0}" already exists, rule not imported.', [name]);
gs.addErrorMessage(msg);
return false;
}
mappingRule.initialize();
mappingRule.name = name;
mappingRule.event_class = source;
mappingRule.mapping_type = '1'; //singleField type
mappingRule.from_field = fromField;
mappingRule.to_field = toField;
return mappingRule.insert();
},
insertEventMappingPair: function(mapping_id, key, value) {
var mappingPair = new GlideRecord('em_mapping_pair');
mappingPair.initialize();
mappingPair.mapping_rule = mapping_id;
mappingPair.key = key;
mappingPair.value = value;
mappingPair.insert();
},
insertMatchRule: function(swId, name, source, ignore, order, ciTypeName) {
var matchRule = new GlideRecord('em_match_rule');
matchRule.initialize();
matchRule.addQuery('name', name);
matchRule.query();
if (matchRule.hasNext()) {
var msg = gs.getMessage('A transform rule named "{0}" already exists, rule not imported.', [name]);
gs.addErrorMessage(msg);
return null;
}
matchRule.initialize();
matchRule.name = name;
matchRule.event_class = source;
matchRule.ignore_event = ignore;
matchRule.order = order;
matchRule.ci_type = ciTypeName;
//matchRule.sys_id = convertId(swId);
return matchRule.insert();
},
insertMatchField: function(match_id, field, mapping, regex) {
var matchField = new GlideRecord('em_match_field');
matchField.initialize();
matchField.match_rule = match_id;
matchField.field = field;
matchField.mapping = mapping;
matchField.regexp = regex;
matchField.insert();
},
insertComposeField: function(match_id, field, composingFields) {
var composeField = new GlideRecord('em_compose_field');
composeField.initialize();
composeField.match_rule = match_id;
composeField.field = field;
composeField.composition = composingFields;
composeField.insert();
},
translateField: function(field) {
field = '' + field;
switch (field) {
case 'hostAddress':
field = 'node';
break;
case 'messageKey':
field = 'message_key';
break;
case 'resolutionState':
field = 'resolution_state';
break;
case 'text':
field = 'description';
default:
break;
}
return field;
},
translateComposition: function(composition) {
composition = '' + composition;
if (composition.indexOf("${hostAddress}") >= 0)
composition = composition.replace("${hostAddress}", "${node}");
if (composition.indexOf("${messageKey}") >= 0)
composition = composition.replace("${messageKey}", "${message_key}");
if (composition.indexOf("${resolutionState}") >= 0)
composition = composition.replace("${resolutionState}", "${resolution_state}");
if (composition.indexOf("${text}") >= 0)
composition = composition.replace("${text}", "${description}");
return composition;
},
translateSeverity: function(severity) {
severity = '' + severity;
switch (severity) {
case 'CRITICAL':
severity = '1';
break;
case 'MAJOR':
severity = '2';
break;
case 'WARNING':
severity = '4';
break;
case 'MINOR':
severity = '3';
break;
case 'INFORMATION':
severity = '5';
default:
break;
}
return severity;
},
translateState: function(state) {
state = '' + state;
switch (state) {
case 'NEW':
state = 'New';
break;
case 'CLOSED':
state = 'Closing';
default:
break;
}
return state;
},
isFieldMappingRunAfterBindingEnabled: function() {
var enabled = gs.getProperty(this.FIELD_MAPPING_RUN_AFTER_BINDING_ENABLED_PROPERTY,
this.FIELD_MAPPING_RUN_AFTER_BINDING_ENABLED_DEFAULT_VALUE);
return enabled == "true";
},
getFieldMappingFromFieldObject: function(fromField) {
if (typeof fromField != 'string')
return;
var prefix = this.getFromFieldPrefix(fromField);
var field = fromField.toLowerCase().substring(prefix.length);
return {
prefix: prefix,
field: field
};
},
getFromFieldPrefix: function(fromField) {
if (typeof fromField != 'string')
return;
fromField = fromField.toLowerCase();
var prefixes = [
this.getFieldMappingFromFieldCmdbCiPrefix(),
this.getFieldMappingFromFieldCmdbKeyValuePrefix(),
this.getFieldMappingFromFieldAddInfoPrefix()
];
for (var i = 0; i < prefixes.length; i++) {
var prefix = prefixes[i];
if (fromField.startsWith(prefix))
return prefix;
}
// Default value if a prefix was not found
return '';
},
getFieldMappingFromFieldCmdbCiPrefix: function() {
return gs.getProperty(this.FIELD_MAPPING_FROM_FIELD_CMDB_CI_PROPERTY, this.FIELD_MAPPING_FROM_FIELD_CMDB_CI_DEFAULT_VALUE);
},
getFieldMappingFromFieldCmdbKeyValuePrefix: function() {
return gs.getProperty(this.FIELD_MAPPING_FROM_FIELD_CMDB_KEY_VALUE_PROPERTY, this.FIELD_MAPPING_FROM_FIELD_CMDB_KEY_VALUE_DEFAULT_VALUE);
},
getFieldMappingFromFieldAddInfoPrefix: function() {
return gs.getProperty(this.FIELD_MAPPING_FROM_FIELD_ADD_INFO_VALUE_PROPERTY, this.FIELD_MAPPING_FROM_FIELD_ADD_INFO_DEFAULT_VALUE);
},
isFieldMappingTypeSupportedWithRunAfterBinding: function(fieldMappingTypeValue) {
if (!(Number(fieldMappingTypeValue) && parseInt(fieldMappingTypeValue, 10)))
return;
var v = parseInt(fieldMappingTypeValue, 10);
return this.SUPPORTED_FIELD_MAPPING_TYPES_WITH_RUN_AFTER_BINDING.indexOf(v) >= 0;
},
type: 'EventRuleUtil'
}
Sys ID
755d7cb2d7422100b9bc43d60e6103da