Name

sn_cimaf.CIActionHelperSNC

Description

No description available

Script

var CIActionHelperSNC = Class.create();
CIActionHelperSNC.prototype = {
  initialize: function() {},

  TABLES: {
  	ACTION_REQUEST: "sn_cimaf_action_request",
  	ACTION_OUTPUT: "sn_cimaf_action_output",
  	ACTION_CONFIG: "sn_cimaf_action_config",
  	CMDB_CI: "cmdb_ci"
  },

  FIELDS: {
  	ACTION_CONFIG: "action_config",
  	STATE: "state",
  	CONFIGURATION_ITEM: "configuration_item",
  	USER_EXECUTED: "user_executed",
  	ACTION_PARAMETERS: "action_parameters",
  	ACTION_COMMAND: "action_command",
  	REQUEST_ID: "request_id",
  	ACTION_REQUEST: "action_request",
  	PAYLOAD: "payload",
  	SYS_DOMAIN: "sys_domain"
  },

  ACTION_STATES: {
  	IN_PROGRESS: "in_progress",
  	FAILED: "failed",
  	COMPLETED: "completed",
  	VALIDATION_FAILURE: "validation_failure"
  },

  addActionRequest: function(actionConfigGrOrSysId, cmdbGrOrSysId, actionParams) {
  	var actionConfigSysId = this._getSysId(actionConfigGrOrSysId);
  	var cmdbSysId = this._getSysId(cmdbGrOrSysId);
  	actionParams = actionParams || {};
  	
  	if (!actionConfigSysId || !cmdbSysId) {
  		gs.error("addActionRequest: invalid inputs");
  		return;
  	}
  	var gr = new GlideRecord(this.TABLES.ACTION_REQUEST);
  	gr.initialize();
  	gr.setValue(this.FIELDS.ACTION_CONFIG, actionConfigSysId);
  	gr.setValue(this.FIELDS.STATE, this.ACTION_STATES.IN_PROGRESS);
  	gr.setValue(this.FIELDS.CONFIGURATION_ITEM, cmdbSysId);
  	gr.setValue(this.FIELDS.USER_EXECUTED, gs.getUserID());
  	this._setGlideVarInputs(gr, this.FIELDS.ACTION_PARAMETERS, actionParams);
  	return gr.insert();
  },

  updateActionRequestById: function(actionRequestSysId, state) {
  	if (!actionRequestSysId || !state) {
  		gs.error("updateActionRequestById: invalid inputs");
  		return;
  	}
  	var actionRequestGr = new GlideRecord(this.TABLES.ACTION_REQUEST);
  	if (actionRequestGr.get(actionRequestSysId)) {
  		return this.updateActionRequest(actionRequestGr, state);
  	}
  },

  updateActionRequest: function(actionRequestGr, state) {
  	if (!this._isValidGr(actionRequestGr) || !state) {
  		gs.error("updateActionRequest: invalid inputs");
  		return;
  	}
  	actionRequestGr.setValue(this.FIELDS.STATE, state);
  	return actionRequestGr.update();
  },

  addActionOutput: function(requestId, actionCommandGrOrSysId, actionRequestGrOrSysId) {
  	var actionCommandSysId = this._getSysId(actionCommandGrOrSysId);
  	var actionRequestSysId = this._getSysId(actionRequestGrOrSysId);

  	if (!requestId || !actionCommandSysId || !actionRequestSysId) {
  		gs.error("addActionOutput: invalid inputs");
  		return;
  	}
  	var gr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	gr.initialize();
  	gr.setValue(this.FIELDS.REQUEST_ID, requestId);
  	gr.setValue(this.FIELDS.ACTION_COMMAND, actionCommandSysId);
  	gr.setValue(this.FIELDS.ACTION_REQUEST, actionRequestSysId);
  	gr.setValue(this.FIELDS.STATE, this.ACTION_STATES.IN_PROGRESS);
  	return gr.insert();
  },

  updateActionOutputByRequestId: function(requestId, payload) {
  	if (!requestId) {
  		gs.error("updateActionOutputByRequestId: invalid inputs");
  		return;
  	}
  	var actionOutputGr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	actionOutputGr.addQuery(this.FIELDS.REQUEST_ID, requestId);
  	actionOutputGr.query();
  	if (actionOutputGr.next()) {
  		return this.updateActionOutput(actionOutputGr, payload);
  	}
  },

  updateActionOutputById: function(actionOutputSysId, payload) {
  	if (!actionOutputSysId) {
  		gs.error("updateActionOutputById: invalid input");
  		return;
  	}
  	var actionOutputGr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	if (actionOutputGr.get(actionOutputSysId)) {
  		return this.updateActionOutput(actionOutputGr, payload);
  	}
  },

  updateActionOutput: function(actionOutputGr, payload) {
  	if (!this._isValidGr(actionOutputGr)) {
  		gs.error("updateActionOutput: invalid input");
  		return;
  	}
  	try {
  		payload = JSON.stringify(payload);
  	} catch (e) {
  		gs.error("updateActionOutput: invalid payload object");
  	}
  	actionOutputGr.setValue(this.FIELDS.STATE, this.ACTION_STATES.COMPLETED);
  	actionOutputGr.setValue(this.FIELDS.PAYLOAD, payload);
  	return actionOutputGr.update();
  },

  handleActionOutputErrorByRequestId: function(requestId, errorPayload) {
  	if (!requestId) {
  		gs.error("handleActionOutputErrorByRequestId: invalid input");
  		return;
  	}
  	var actionOutputGr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	actionOutputGr.addQuery(this.FIELDS.REQUEST_ID, requestId);
  	actionOutputGr.query();
  	if (actionOutputGr.next()) {
  		return this.handleActionOutputError(actionOutputGr, errorPayload);
  	}
  },

  handleActionOutputErrorById: function(actionOutputSysId, errorPayload) {
  	if (!actionOutputSysId) {
  		gs.error("handleActionOutputErrorById: invalid input");
  		return;
  	}
  	var actionOutputGr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	if (actionOutputGr.get(actionOutputSysId)) {
  		return this.handleActionOutputError(actionOutputGr, errorPayload);
  	}
  },

  handleActionOutputError: function(actionOutputGr, errorPayload) {
  	if (!actionOutputGr) {
  		gs.error("handleActionOutputError: invalid inputs");
  		return;
  	}
  	try {
  		errorPayload = JSON.stringify(errorPayload);
  	} catch (e) {
  		gs.error("handleActionOutputError: invalid error payload object");
  	}
  	actionOutputGr.setValue(this.FIELDS.STATE, this.ACTION_STATES.FAILED);
  	actionOutputGr.setValue(this.FIELDS.PAYLOAD, errorPayload);
  	return actionOutputGr.update();
  },

  handleActionOutputValidationFailureByRequestId: function(requestId) {
  	if (!requestId) {
  		gs.error("handleActionOutputValidationFailureByRequestId: invalid input");
  		return;
  	}
  	var actionOutputGr = new GlideRecord(this.TABLES.ACTION_OUTPUT);
  	actionOutputGr.addQuery(this.FIELDS.REQUEST_ID, requestId);
  	actionOutputGr.query();
  	if (actionOutputGr.next()) {
  		return this.handleActionOutputValidationFailure(actionOutputGr);
  	}
  },

  handleActionOutputValidationFailure: function(actionOutputGr) {
  	if (!actionOutputGr) {
  		gs.error("handleActionOutputValidationFailure: invalid inputs");
  		return;
  	}
  	actionOutputGr.setValue(this.FIELDS.STATE, this.ACTION_STATES.VALIDATION_FAILURE);
  	return actionOutputGr.update();
  },

  isSysId: function(nameOrSysId) {
  	return nameOrSysId.length === 32 && /^[a-zA-Z0-9]+$/.test(nameOrSysId);
  },

  _isValidGr: function(gr) {
  	if (gr && gr instanceof GlideRecord && gr.isValidRecord())
  		return true;
  },

  _getSysId: function(grOrSysId) {
  	return this._isValidGr(grOrSysId) ? grOrSysId.getUniqueValue() : grOrSysId;
  },

  _getGlideRecord: function(tableName, sysId) {
  	var gr = new GlideRecord(tableName);
  	if (gr.get(sysId))
  		return gr;
  },

  _getGlideRecordByInternalName: function(tableName, sysId) {
  	var gr = new GlideRecord(tableName);
  	if (gr.get('internal_name', recordName))
  		return gr;
  },

  _setGlideVarInputs: function(gr, field, inputs) {
  	for (var input in inputs) {
  		if (this._isValidGr(inputs[input]))
  			gr[field][input] = inputs[input].getUniqueValue();
  		else
  			gr[field][input] = inputs[input];
  	}
  },

  type: 'CIActionHelperSNC'
};

Sys ID

418ff80d53655110a0d6ddeeff7b1237

Offical Documentation

Official Docs: