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

Offical Documentation

Official Docs: