Name
sn_install_base.InstallBaseItemAPIHelperSNC
Description
No description available
Script
var InstallBaseItemAPIHelperSNC = Class.create();
InstallBaseItemAPIHelperSNC.prototype = {
initialize: function() {
//local object to store the attrib details of the table
/* the object will hold data like
{
"<tableName>":{
"mandatoryFields":[],
"acceptableFields":[]
}
}*/
this.tableDetails = {};
},
/*
* returns the error objects with "Forbidden" error message
*/
forBiddenMessage: function(msg) {
var message = InstallBaseItemAPIConstants.API_MESSAGES.FORBIDDEN(msg);
return InstallBaseItemAPIHelper.getErrorObject(message, message, InstallBaseItemAPIConstants.API_STATUS_CODES.FORBIDDEN);
},
/*
* returns the error objects with resource not found error message
*/
resourceNotFound: function() {
return InstallBaseItemAPIHelper.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.RESOURCE_NOT_FOUND, InstallBaseItemAPIConstants.API_MESSAGES.RESOURCE_NOT_FOUND, InstallBaseItemAPIConstants.API_STATUS_CODES.NOT_FOUND);
},
/*
* returns the error objects with default request cannot process error message
*/
requestCannotProcess: function(errorMessage, errorDetail, errorCode) {
var errMsg = !gs.nil(errorMessage) ? errorMessage : InstallBaseItemAPIConstants.API_MESSAGES.REQUEST_CANNOT_BE_PROCESSED;
var errDetail = !gs.nil(errorDetail) ? errorDetail : InstallBaseItemAPIConstants.API_MESSAGES.REQUEST_CANNOT_BE_PROCESSED;
var errCode = !gs.nil(errorCode) ? errorCode : InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR;
return InstallBaseItemAPIHelper.getErrorObject(errMsg, errDetail, errCode);
},
operationCannotBePerformed: function(operation) {
var msg = InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
detail = InstallBaseItemAPIConstants.API_MESSAGES.REQUEST_FAILED(operation),
errorCode = InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR;
return InstallBaseItemAPIHelper.getErrorObject(msg, detail, errorCode);
},
/*
* Implementation of canRead.
*/
canRead: function(recordGr) {
return recordGr.canRead();
},
/*
* Implementation of canWrite.
*/
canWrite: function(recordGr) {
return recordGr.canWrite();
},
/*
* Implementation of canCreate.
*/
canCreate: function(recordGr) {
return recordGr.canCreate();
},
/**
* Implementation of canDelete.
*/
canDelete: function(recordGr) {
return recordGr.canDelete();
},
/*
* Returns the JSON format of glide records with only the selected fields.
*/
getJSONFromGR: function(gr, ignoreFields) {
var jsonObj = {};
for (var attr in gr) {
if (!gr.isValidField(attr) || ignoreFields.indexOf(attr) >= 0)
continue;
var attrVal = gr.getValue(attr);
if (!gs.nil(attrVal)) {
var ed = gr[attr + ''].getED();
var type = ed.getInternalType();
if (type == 'reference')
jsonObj[attr] = {
"sys_id": attrVal,
"display_value": gr.getDisplayValue(attr)
};
else if (ed.isChoiceTable() || type == 'glide_date_time') {
jsonObj[attr] = {
"value": attrVal,
"display_value": gr.getDisplayValue(attr)
};
} else if(type=='glide_list') {
jsonObj[attr] = {
"values": attrVal.split(','),
"display_values": gr.getDisplayValue(attr).split(', ')
};
} else if (type == 'boolean') {
jsonObj[attr] = gr.getDisplayValue(attr);
} else
jsonObj[attr] = attrVal;
}
}
return jsonObj;
},
/*
* Check if the sysId is valid record or not.
*/
isValidSysId: function(tableName, sysId) {
var recordGr = new GlideRecord(tableName);
if (recordGr.get(sysId))
return true;
return false;
},
/*
* Fetch the GlideRecord for the given sysId.
*/
getRecord: function(tableName, sysId) {
var recordGr = new GlideRecord(tableName);
recordGr.get(sysId);
return recordGr;
},
/*
* Check whether the install base item has children or not
*/
installBaseItemHasChildren: function(ibItemSysId) {
var hasChildGr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_ITEM);
hasChildGr.addQuery("parent", ibItemSysId);
hasChildGr.setLimit(1);
hasChildGr.query();
return hasChildGr.hasNext();
},
/*
* Get Maintenance Plans for given IB.
*/
getMaintenancePlansForIB: function(ibItemSysId) {
var ibGR = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_ITEM);
ibGR.get(ibItemSysId);
var tableName = ibGR.getValue('sys_class_name');
var mPlans = new sn_install_base.InstallBaseUtil().getMaintenancePlansForIB(ibItemSysId, tableName);
return mPlans.join(",");
},
type: 'InstallBaseItemAPIHelperSNC'
};
//function to check if the passed in refrence value is valid
InstallBaseItemAPIHelper.validateReferenceQualifier = function(refList, gr) {
for (var refField in refList) {
var reference_table = gr[refField].getRefRecord().getTableName();
var gr2 = new GlideRecordSecure(reference_table);
var reference_qual = gr[refField].getED().getReferenceQualifier();
if (reference_qual && reference_qual.indexOf('javascript:') != -1) {
reference_qual = global.CSMBaseAPIUtils.evaluateJSReferenceQualifier(reference_qual, gr);
}
var refSysId = refList[refField];
if (!gs.nil(refSysId)) {
var query = 'sys_id=' + refSysId;
reference_qual = reference_qual ? (reference_qual + '^' + query) : query;
}
if (reference_qual)
gr2.addEncodedQuery(reference_qual);
gr2.query();
if (!gr2.next()) {
var msgArray = [refField, refList[refField]];
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_REFERENCE(msgArray));
}
}
return true;
};
/*
* Validate if the install base item being created is valid table name
* and it is an extension of the base install base item
*/
InstallBaseItemAPIHelper.validateClass = function(tableName, baseTable) {
var tab = new GlideTableHierarchy(baseTable);
var hierarchy = tab.getAllExtensions();
if(Array.isArray(tableName)) {
tableName = tableName[0];
}
if (gs.nil(tableName) || hierarchy.indexOf(tableName) < 0) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST, InstallBaseItemAPIConstants.API_MESSAGES.INVALID_TABLE_NAME(tableName), InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR);
}
return tableName;
},
/*
* Validate mandatory fields
*/
InstallBaseItemAPIHelper.validateMandatoryFieldsPassed = function(params, mandatoryFields) {
for (var i = 0; i < mandatoryFields.length; i++) {
if (gs.nil(params[mandatoryFields[i]])) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.MANDATORY_ERROR(mandatoryFields[i]), InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR);
}
}
};
InstallBaseItemAPIHelper.validateDataByType = function(attr, attrValue, glideRecord, baseTable) {
//if the attributeis items then return
if (attr == "items")
return attrValue;
if (!glideRecord.isValidField(attr))
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_ATTRIBUTE_INVALID(attr));
var element = glideRecord.getElement(attr);
var ed = element.getED();
var errorResults = {};
if (gs.nil(attrValue))
return attrValue;
// data check for each type
var elementType = ed.getInternalType();
var result = attrValue;
switch (elementType) {
case "integer":
result = this.validateInteger(attr, attrValue);
if (!gs.nil(result.error)) {
return result;
}
break;
case "reference":
result = this.validateGetReference(ed, element, attr, attrValue);
if (!gs.nil(result.error)) {
return result;
}
break;
case "glide_date_time":
result = this.validateDateTime(attr, attrValue);
if (!gs.nil(result.error)) {
return result;
}
break;
case "boolean":
result = this.validateBoolean(attr, attrValue);
if (!gs.nil(result.error)) {
return result;
}
break;
case "string":
if (ed.isChoiceTable()) {
result = this.validateChoice(element, attr, attrValue);
if (!gs.nil(result.error)) {
return result;
}
}
break;
case "sys_class_name":
if (gs.nil(baseTable))
baseTable = global.CSMBaseConstants.INSTALL_BASE_ITEM;
result = this.validateClass(attrValue, baseTable);
if (!gs.nil(result.error)) {
return result;
}
break;
default:
return attrValue;
}
return result;
};
//Get the install base item mandatory fields.
InstallBaseItemAPIHelper.getMandatoryFields = function(gr) {
return InstallBaseItemAPIConstants.TableAttributes.INSTALL_BASE_MANDATORY_ATTRIBUTES;
};
//Validate integer
InstallBaseItemAPIHelper.validateInteger = function(attr, attrValue) {
var intValue = this.strictParseInt(attrValue);
if (gs.nil(intValue)) {
var msgArray = [attr, attrValue];
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_INTEGER(msgArray));
}
//return the same value as this will be assigned back to variable
//this is to ensure consistent api returns for reference fields and choice lists.
return attrValue;
};
/*
Validate date time for specific format
*/
InstallBaseItemAPIHelper.validateDateTime = function(attr, attrValue) {
//valdiate reference
try {
var dateFormat = 'yyyy-MM-dd HH:mm:ss'; // to get from user profile
var gdt = new GlideDateTime();
var msgArray = [dateFormat, attr, attrValue];
gdt.setDisplayValue(attrValue, dateFormat);
if (!gdt.isValid()) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_DATETIME(msgArray));
}
} catch (e) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_DATETIME(msgArray));
}
return attrValue;
};
InstallBaseItemAPIHelper.validateBoolean = function(attr, attrValue) {
var msgArray = ['true/false', attr, attrValue];
if (!(attrValue == true || attrValue == false)) {
switch(attrValue.trim())
{
case "true":
return true;
case "false":
return false;
default:
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST, InstallBaseItemAPIConstants.API_MESSAGES.INVALID_BOOLEAN_VALUE(msgArray));
}
}
return (attrValue == true) ? true : false;
};
/*
Returns only numbers.
*/
InstallBaseItemAPIHelper.strictParseInt = function(value) {
if (/^[-+]?(\d+|Infinity)$/.test(value)) {
return Number(value);
} else {
return null;
}
};
/*
Query the reference fields value based on the referenced table, and check if its valid.
*/
InstallBaseItemAPIHelper.validateGetReference = function(ed, element, attr, attrValue, gr) {
//valdiate reference
var reference_table = element.getRefRecord().getTableName();
var refGR = new GlideRecordSecure(reference_table);
if (refGR.get(attrValue)) {
if(refGR.getRowCount() == 1)
return refGR.getValue("sys_id");
else
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.CANNOT_RESOLVE_RECORD(attrValue));
}
else {
var msgArray = [attr, attrValue];
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_REFERENCE(msgArray));
}
};
InstallBaseItemAPIHelper.validateChoice = function(element, attr, attrValue) {
var choiceList = element.getChoices();
var arrayUtil = new global.ArrayUtil();
if (!arrayUtil.contains(choiceList, attrValue)) {
var msgArray = [attr, attrValue];
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.INVALID_CHOICE(msgArray));
}
//valdiate reference
return attrValue;
};
//roll back api to remove the install base item created if a failure happens latter
InstallBaseItemAPIHelper.removeCreatedInstallBaseItems = function(createdItemList) {
var gr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_ITEM);
for (var item in createdItemList)
if (gr.get(createdItemList[item])) {
gr.deleteRecord();
}
};
InstallBaseItemAPIHelper.getErrorObject = function(errorMessage, errorDetail, errorCode) {
var errorObject = {};
errorCode = gs.nil(errorCode) ? InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR : errorCode;
errorObject.error = {
errorCode: errorCode,
errorMessage: errorMessage,
errorDetail: errorDetail
};
return errorObject;
};
/*
* Check whether the table is extended by Install Base Item
*/
InstallBaseItemAPIHelper.isInstallBaseChildTable = function(tableName) {
var a = new GlideRecord(InstallBaseItemAPIConstants.DB_OBJECT_TABLE);
a.get('name', global.CSMBaseConstants.INSTALL_BASE_ITEM);
return a.getValue('super_class') == InstallBaseItemAPIConstants.INSTALL_BASE_TABLE_ID;
};
/*
* Check the payload is empty or not.
*/
InstallBaseItemAPIHelper.isEmptyPayload = function(payload) {
if (Object.keys(payload).length == 0) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_NO_ATTRIBUTE_FOUND(),
InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_NO_ATTRIBUTE_FOUND());
}
return true;
};
/*
* Build a map of attributes that are mandatory and acceptable for a item class
*/
InstallBaseItemAPIHelper._populateTableMetaData = function(tableName) {
//TODO: add validation of table name
var gr = new GlideRecord(tableName);
var ignorePostAttributes = InstallBaseItemAPIConstants.ExcludeTableAttributes.PostInstallBaseRestrictedAttributes();
if (this.tableDetails[tableName])
return;
var tabDetail = {
mandatoryFields: [],
acceptableFields: ["items"]
};
var tableDetailsGr = new GlideRecord(tableName);
tableDetailsGr.setLimit(1);
tableDetailsGr.query();
tableDetailsGr.next();
for (var attr in tableDetailsGr) {
var elements = tableDetailsGr.getElements();
for (i = 0; i < elements.length; i++) {
if (!(ignorePostAttributes.indexOf(attr + '') >= 0))
tabDetail.acceptableFields.push(elements[i].getED().getName());
if (elements[i].getED().isMandatory() && !elements[i].getED().isAutoOrSysID())
tabDetail.mandatoryFields.push(elements[i].getED().getName());
}
}
this.tableDetails[tableName] = tabDetail;
},
/*
* Get the possible fields that can be accepted
*/
InstallBaseItemAPIHelper.getAcceptableFieldsForPut = function(tableName) {
if (gs.nil(this.tableDetails))
this.tableDetails = {};
if (gs.nil(this.tableDetails[tableName]))
this._populateTableMetaData(tableName);
return this.tableDetails[tableName].acceptableFields;
},
/*
* Get mandatory attrirubtes
*
*/
InstallBaseItemAPIHelper.getMandatoryFields = function(tableName) {
if (gs.nil(this.tableDetails))
this.tableDetails = {};
if (gs.nil(this.tableDetails[tableName]))
this._populateTableMetaData(tableName);
return this.tableDetails[tableName].mandatoryFields;
},
InstallBaseItemAPIHelper.validateInstallBaseItemPayload = function(payload) {
//Validate the payload
var response = this.isEmptyPayload(payload);
if (!gs.nil(response.error)) {
return response;
}
if (!gs.nil(payload.sys_class_name)) {
var tableVal = this.validateClass(payload.sys_class_name, global.CSMBaseConstants.INSTALL_BASE_ITEM);
if (!gs.nil(tableVal.error)) {
return tableVal;
}
}
//Validate attributes and its value data types.
var allowedAttributes = null;
var tableName = !gs.nil(payload.sys_class_name) ? payload.sys_class_name : global.CSMBaseConstants.INSTALL_BASE_ITEM;
allowedAttributes = this.getAcceptableFieldsForPut(tableName);
var installBaseGr = new GlideRecord(tableName);
var keys = Object.keys(payload);
var errorObj = null;
//check if any mandatory field value is not passed
var mandatoryAttribs = this.getMandatoryFields(tableName);
for (var m = 0; m < mandatoryAttribs.length; m++) {
var field = mandatoryAttribs[m];
var index = keys.indexOf(field);
if (index < 0)
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST, InstallBaseItemAPIConstants.API_MESSAGES.MANDATORY_ATTRIBUTE_MISSING(field));
if (gs.nil(payload[keys[index]]) || payload[keys[index]].trim() === '')
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST, InstallBaseItemAPIConstants.API_MESSAGES.MANDATORY_ATTRIBUTE_MISSING(field));
}
for (var i = 0; i < keys.length; i++) {
var field = keys[i];
if (allowedAttributes.indexOf(field) == -1) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.INVALID_ATTRIBUTE_FOUND,
InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_ATTRIBUTE_INVALID(field));
}
var result = this.validateDataByType(field, payload[field], installBaseGr);
if (!gs.nil(result) && !gs.nil(result.error)) {
return result;
} else {
payload[field] = result;
}
}
return true;
};
InstallBaseItemAPIHelper.validateInstallBaseItemPayloadForPUT = function(payload) {
//Validate the payload
var response = this.isEmptyPayload(payload);
if (!gs.nil(response.error)) {
return response;
}
var tableName = global.CSMBaseConstants.INSTALL_BASE_ITEM;
if (!gs.nil(payload.sys_class_name)) {
var tableVal = this.validateClass(payload.sys_class_name, tableName);
if (!gs.nil(tableVal.error)) {
return tableVal;
}
tableName = payload.sys_class_name;
}
//append tablename to the payload
payload['sys_class_name'] = tableName;
//Validate attributes and its value data types.
var allowedAttributes = null;
allowedAttributes = this.getAcceptableFieldsForPut(tableName);
var installBaseGr = new GlideRecord(tableName);
var keys = Object.keys(payload);
var errorObj = null;
for (var i = 0; i < keys.length; i++) {
var field = keys[i];
if (allowedAttributes.indexOf(field) == -1 || field == 'items') {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.INVALID_ATTRIBUTE_FOUND,
InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_ATTRIBUTE_INVALID(field));
}
var result = this.validateDataByType(field, payload[field], installBaseGr);
if (!gs.nil(result) && !gs.nil(result.error)) {
return result;
} else {
payload[field] = result;
}
}
return true;
};
InstallBaseItemAPIHelper._fillResponsibility = function(payload) {
if(!gs.nil(payload.type) && gs.nil(payload.responsibility))
{
var relatedPartyGr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
//Convert to sys_id
var type = this.validateDataByType('type', payload.type, relatedPartyGr);
//Query for default responsibility
var typeGr = new GlideRecord(global.CSMBaseConstants.RELATED_PARTY_CONFIG_TABLE);
typeGr.addQuery('sys_id', type);
typeGr.query();
if (typeGr.next())
{
payload.responsibility = typeGr.default_responsibility;
}
}
};
InstallBaseItemAPIHelper.validatePayloadForCreatingRP = function(payload, installBaseItemId) {
//Validate the payload
var response = this.isEmptyPayload(payload);
if (!gs.nil(response.error)) {
return response;
}
payload['install_base_item'] = installBaseItemId;
var relatedPartyGR;
if (!gs.nil(payload.sys_class_name)) {
var tableVal = this.validateClass(payload.sys_class_name, global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
if(!gs.nil(tableVal.error)){
return tableVal;
}
relatedPartyGr = new GlideRecord(payload.sys_class_name);
} else
relatedPartyGr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
//check and fill default responsibility if required
this._fillResponsibility(payload);
var keys = Object.keys(payload);
for (var i = 0; i < keys.length; i++) {
var result = InstallBaseItemAPIHelper.validateDataByType(keys[i], payload[keys[i]], relatedPartyGr, global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
if (!gs.nil(result.error)) {
return result;
}else {
payload[keys[i]] = result;
}
}
return true;
};
InstallBaseItemAPIHelper.validateIBPayloadToUninstall = function(payload) {
var keys = Object.keys(payload);
if (keys.length == 0) return true;
var uninstallDateFieldName = 'uninstall_date';
if (!(keys[0] == uninstallDateFieldName)) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST,
InstallBaseItemAPIConstants.API_MESSAGES.MANDATORY_ERROR(uninstallDateFieldName));
}
//Validate attributes and its value data types.
var allowedAttributes = InstallBaseItemAPIConstants.TableAttributes.IB_UNINSTALL_PAYLOAD_ATTRIBUTES;
var installBaseGr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_ITEM);
for (var i = 0; i < keys.length; i++) {
var field = keys[i];
if (allowedAttributes.indexOf(field) == -1) {
return this.getErrorObject(InstallBaseItemAPIConstants.API_MESSAGES.INVALID_ATTRIBUTE_FOUND,
InstallBaseItemAPIConstants.API_MESSAGES.INSTALL_BASE_ATTRIBUTE_INVALID(field));
}
var result = this.validateDataByType(field, payload[field], installBaseGr);
if (!gs.nil(result) && !gs.nil(result.error)) {
return result;
} else {
payload[field] = result;
}
}
return true;
};
InstallBaseItemAPIHelper.validateRPPayloadForPatch = function(installBaseItemId, payload) {
//Validate the payload
var response = this.isEmptyPayload(payload);
if (!gs.nil(response.error)) {
return response;
}
if (gs.nil(payload.install_base_item))
payload['install_base_item'] = installBaseItemId;
var relatedPartyGR;
if (!gs.nil(payload.sys_class_name)) {
var tableVal = this.validateClass(payload.sys_class_name, global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
if (!gs.nil(tableVal.error)) {
return tableVal;
}
relatedPartyGr = new GlideRecord(payload.sys_class_name);
} else
relatedPartyGr = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
//check and fill default responsibility if required
this._fillResponsibility(payload);
var keys = Object.keys(payload);
for (var i = 0; i < keys.length; i++) {
var result = InstallBaseItemAPIHelper.validateDataByType(keys[i], payload[keys[i]], relatedPartyGr, global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
if (!gs.nil(result.error)) {
return result;
} else {
payload[keys[i]] = result;
}
}
return true;
};
InstallBaseItemAPIHelper.validatePayloadToDeleteRP = function(installBaseItemId, relatedPartyId) {
var relatedPartyGR = new GlideRecord(global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
if (relatedPartyGR.get(relatedPartyId) &&
relatedPartyGR.getValue(InstallBaseItemAPIConstants.INSTALL_BASE_FIELD) == installBaseItemId) {
return true;
}
return new InstallBaseItemAPIHelper().resourceNotFound();
};
InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams = function(queryParams, nonQueryingParams, baseTableName) {
var result = {};
if (!gs.nil(queryParams)) {
var installBaseGR,
className = queryParams[InstallBaseItemAPIConstants.CLASS_NAME];
if (!gs.nil(className)) {
var classValidate = InstallBaseItemAPIHelper.validateClass(className, baseTableName);
if (!gs.nil(classValidate.error)) {
classValidate.error.errorCode = InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR;
return classValidate;
}
installBaseGR = new GlideRecordSecure(className);
} else {
installBaseGR = new GlideRecordSecure(baseTableName);
}
installBaseGR.initialize();
var errorMsg;
var params = Object.keys(queryParams);
if (params.length > 0)
params.every(function(field) {
if (field != InstallBaseItemAPIConstants.CLASS_NAME && field != InstallBaseItemAPIConstants.SYSPARM_CONTEXT && (gs.nil(nonQueryingParams) || nonQueryingParams.indexOf(field) < 0)) {
var fieldValue = queryParams[field];
if (!gs.nil(fieldValue) && fieldValue.length > 0) {
fieldValue = fieldValue[0];
}
var updatedFieldValue = InstallBaseItemAPIHelper.validateDataByType(field, fieldValue, installBaseGR, className);
if (!gs.nil(updatedFieldValue) && !gs.nil(updatedFieldValue.error)) {
updatedFieldValue.error.errorCode = InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR;
errorMsg = updatedFieldValue;
return false;
} else {
queryParams[field] = updatedFieldValue;
}
}
});
if (!gs.nil(errorMsg)) {
return errorMsg;
}
}
return result;
};
InstallBaseItemAPIHelper.validateIB = function(id) {
if (!new InstallBaseItemAPIHelper().isValidSysId(global.CSMBaseConstants.INSTALL_BASE_ITEM, id)) {
var msg = InstallBaseItemAPIConstants.API_MESSAGES.RESOURCE_NOT_FOUND;
return InstallBaseItemAPIHelper.getErrorObject(msg, msg, InstallBaseItemAPIConstants.API_STATUS_CODES.NOT_FOUND);
}
return true;
};
Sys ID
4f008de523d12110e32f13d1d7bf6506