Name

sn_install_base.InstallBaseItemAPIBaseSNC

Description

No description available

Script

var InstallBaseItemAPIBaseSNC = Class.create();
InstallBaseItemAPIBaseSNC.prototype = {
  initialize: function() {
      this.installBaseItemDao = new InstallBaseItemAPIDao();
  	this.apiHelper = new sn_install_base.InstallBaseItemAPIHelper();
  },

  getInstallBaseItemByID: function(id, queryParams) {
      var tableName = global.CSMBaseConstants.INSTALL_BASE_ITEM;

  	//setting startFrom to 0 regardless of the user input.
  	queryParams[InstallBaseItemAPIConstants.SYSPARM_OFFSET] = 0;
  	
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
      if (gs.nil(result.pageParams.depth)) {
          result.pageParams.depth = InstallBaseItemAPIConstants.DEFAULT_DEPT;
      }


      if (!gs.nil(result.queryParams) && !gs.nil(queryParams[InstallBaseItemAPIConstants.CLASS_NAME])) {
          tableName = queryParams[InstallBaseItemAPIConstants.CLASS_NAME];
          var classValidate = InstallBaseItemAPIHelper.validateClass(tableName, global.CSMBaseConstants.INSTALL_BASE_ITEM);
          if (!gs.nil(classValidate.error)) {
              return classValidate;
          }

      }

      var installBaseItem;
      try {
          installBaseItem = this.installBaseItemDao.getInstallBaseItemByID(id, tableName, this.getRestrictedInstallBaseItemAttributes(), result.pageParams);
      } catch (ex) {
  		return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return installBaseItem;
  },

  getInstallBaseItems: function(queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var nonQueryingParams = [InstallBaseItemAPIConstants.RELATED_PARTY_ID, InstallBaseItemAPIConstants.RESPONSIBILITY];
      var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, nonQueryingParams, global.CSMBaseConstants.INSTALL_BASE_ITEM);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }

      var installBaseItems;
      try {
          installBaseItems = this.installBaseItemDao.getInstallBaseItems(result.queryParams, this.getRestrictedInstallBaseItemAttributes(), result.pageParams, nonQueryingParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return installBaseItems;
  },

  getSoldProductsForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.SOLD_PRODUCT);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var soldProducts;
      try {
          soldProducts = this.installBaseItemDao.getInstallBaseSoldProducts(id, result.queryParams, this.getRestrictedSoldProductAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return soldProducts;
  },

  getChildItemsForInstallBase: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.INSTALL_BASE_ITEM);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var childIBs;
      try {
          childIBs = this.installBaseItemDao.getInstallBaseChildItems(id, result.queryParams, this.getRestrictedInstallBaseItemAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return childIBs;
  },

  getEntitlementsForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.ENTITLEMENT_TABLE);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var entitlements;
      try {
          entitlements = this.installBaseItemDao.getInstallBaseEntitlements(id, result.queryParams, this.getRestrictedEntitlementAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return entitlements;
  },

  getContractsForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.CONTRACT_TABLE);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var contracts;
      try {
          contracts = this.installBaseItemDao.getInstallBaseContracts(id, result.queryParams, this.getRestrictedContractAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return contracts;
  },

  getCasesForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.CASE_TABLE);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var cases;
      try {
          cases = this.installBaseItemDao.getInstallBaseCases(id, result.queryParams, this.getRestrictedCaseAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return cases;
  },

  getRelatedPartiesForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.INSTALL_BASE_RELATED_PARTY);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var relatedParties;
      try {
          relatedParties = this.installBaseItemDao.getInstallBaseRelatedParties(id, result.queryParams, this.getRestrictedRelatedPartiesAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return relatedParties;
  },

  getWorkOrdersForInstallBaseItem: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

      var ibValidate = InstallBaseItemAPIHelper.validateIB(id);
      if (!gs.nil(ibValidate.error)) {
          return ibValidate;
      }
  	var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], InstallBaseItemAPIConstants.WO_TABLE);
      if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
      var workOrders;
      try {
          workOrders = this.installBaseItemDao.getInstallBaseWorkOrders(id, result.queryParams, this.getRestrictedWorkOrderAttributes(), result.pageParams);
      } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return workOrders;
  },

  getMaintenancePlansForIB: function(id, queryParams) {
      var result = this._validateRequestParams(queryParams);
      if (!gs.nil(result.error))
          return result;

  var validateParams = InstallBaseItemAPIHelper.validateGetInstallBaseItemsQueryParams(result.queryParams, [], global.CSMBaseConstants.WORK_PLAN_TABLE);
  if (!gs.nil(validateParams.error)) {
          return validateParams;
      }
  var maintenancePlans;
  try {
          maintenancePlans = this.installBaseItemDao.getMaintenancePlansForIB(id, result.queryParams, this.getRestrictedMaintenancePlansAttributes(), result.pageParams);
  } catch (ex) {
          return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.READ);
      }
      return maintenancePlans;
  },



  /*
   * Override this method if you need to change the ignored attributes returned for install base item.
   * industry team will need to override this to add there additional attributes.
   */
  getRestrictedInstallBaseItemAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetInstallBaseRestrictedAttributes();
  },


  /*
   * Override this method if you need to change the attributes returned for sold products.
   */
  getRestrictedSoldProductAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetSoldProductRestrictedAttributes();
  },


  getRestrictedEntitlementAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetEntitlementRestrictedAttributes();
  },

  getRestrictedCaseAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetCaseRestrictedAttributes();
  },

  getRestrictedContractAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetContractRestrictedAttributes();
  },

  getRestrictedRelatedPartiesAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetRelatedPartiesRestrictedAttributes();
  },

  getRestrictedWorkOrderAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetWorkOrderRestrictedAttributes();

  },

  getRestrictedMaintenancePlansAttributes: function() {
      return InstallBaseItemAPIConstants.ExcludeTableAttributes.GetMaintenancePlansRestrictedAttributes();
  },


  /*
   * Create install base item
   */
  createInstallBaseItem: function(context, payload) {
      var installBaseRespItems = [];
      var installBaseResp = {
          status: "SUCCESS"
      };
      var resp = null;
      if (Array.isArray(payload)) {
          for (var i = 0; i < payload.length; i++) {
              resp = this._createSingleInstallBaseItem(payload[i]);
  			installBaseRespItems.push(resp);
          }
      } else {
          resp = this._createSingleInstallBaseItem(payload);
  		installBaseRespItems.push(resp);
      }
      installBaseResp.items = installBaseRespItems;

      var failCount = 0;
      for(var items = 0; items < installBaseRespItems.length; items++)
      {
          if(!gs.nil(installBaseRespItems[items].error))
              failCount++;
      }

      if(!Array.isArray(payload))
          return resp;

      if(failCount>0)
      {
          var msg = InstallBaseItemAPIConstants.API_MESSAGES.MALFORMED_REQUEST;
          var msgDetails = InstallBaseItemAPIConstants.API_MESSAGES.ONE_OR_MORE_IB_CREATION_REQUEST_FAILED(Math.floor(failCount));
          var errorResp = InstallBaseItemAPIHelper.getErrorObject(msg, msgDetails, InstallBaseItemAPIConstants.API_STATUS_CODES.ERROR);
          installBaseResp.error = errorResp.error;
      }
      return installBaseResp;
  },

  /*
   * create a single install base item this payload can have a hierarchy of install base items
   * with the children
   */
  _createSingleInstallBaseItem: function(payload) {
      var result = InstallBaseItemAPIHelper.validateInstallBaseItemPayload(payload);

      if (!gs.nil(result.error)) {
          result.status ="failure";
          return result;
      }
      var response = this.installBaseItemDao.createInstallBaseItem(payload);
      if (!gs.nil(response.error))
          response.item = payload;
      if (!gs.nil(payload.items) && Array.isArray(payload.items)) {
          var respItems = [];
          for (var i = 0; i < payload.items.length; i++) {
              payload.items[i].parent = response.item.sys_id;
              var resp = this._createSingleInstallBaseItem(payload.items[i]);
              if (!gs.nil(resp.error))
                  resp.item = payload.items[i];


              respItems.push(resp);
          }
          response.items = respItems;
      }
      return response;
  },

  /*
   * Validate the payload and update the install base item.
   */
  updateInstallBaseItem: function(context, installBaseItemId, payload) {

      //validate allowed attributes
      var result = InstallBaseItemAPIHelper.validateInstallBaseItemPayloadForPUT(payload);
      if (!gs.nil(result.error))
          return result;
  var installBaseItem;
  try {
      installBaseItem =  this.installBaseItemDao.updateInstallBaseItem(installBaseItemId, payload);
  } catch (ex)
  {
      return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.UPDATE);
  }
  return installBaseItem;
  },

  /*
   * Create related Party
   */
  createRelatedPartyForIB: function(context, installBaseItemId, payload) {
      var result = InstallBaseItemAPIHelper.validatePayloadForCreatingRP(payload, installBaseItemId);
      if (!gs.nil(result.error))
          return result;
  var relatedParty;
      try {
      relatedParty = this.installBaseItemDao.createRelatedParty(payload);
  } catch (ex)
  {
      return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.CREATE);
  }
  return relatedParty;
  },

  /*
   * Validate the payload and uninstall the install base item.
   */
  uninstallInstallBaseItem: function(context, installBaseItemId, payload) {

      var result = InstallBaseItemAPIHelper.validateIBPayloadToUninstall(payload);
      if (!gs.nil(result.error))
          return result;
  	var installBaseItem;
  	try {
  		installBaseItem =  this.installBaseItemDao.uninstallInstallBaseItem(installBaseItemId, payload);
  	} catch (ex)
  	{
  		return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.UNINSTALL);
  	}
  	return installBaseItem;
  },

  /*
   * Validate the payload and update the related party of the install-base item.
   */
  updateRelatedPartyForIB: function(context, installBaseItemId, relatedPartyId, payload) {
      var result = InstallBaseItemAPIHelper.validateRPPayloadForPatch(installBaseItemId, payload);
      if (!gs.nil(result.error))
          return result;
  var relatedParty;
      try {
      relatedParty = this.installBaseItemDao.updateRelatedPartyForIB(relatedPartyId, payload);
  } catch (ex)
  {
      return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.UPDATE);
  }
  return relatedParty;
  },

  /*
   *	validate the payload and delete the related party.
   */
  deleteRelatedParty: function(installBaseItemId, relatedPartyId) {
      var result = InstallBaseItemAPIHelper.validatePayloadToDeleteRP(installBaseItemId, relatedPartyId);
      if (!gs.nil(result.error))
          return result;
  var relatedParty;
      try {
      relatedParty = this.installBaseItemDao.deleteRelatedParty(relatedPartyId);
  } catch (ex)
  {
      return this.apiHelper.operationCannotBePerformed(InstallBaseItemAPIConstants.OPERATION.DELETE);
  }
  return relatedParty;
  },

  /*
   * Since query parameters and control params are coming in same map. we are spliting them here.
   */
  _splitQueryAndPageParams: function(queryParams) {
      var returnMaps = {};
      var pageParams = null;


      if (!gs.nil(queryParams)) {
          for (var field in queryParams) {
              switch (field) {
                  case InstallBaseItemAPIConstants.SYSPARM_OFFSET:
                  case InstallBaseItemAPIConstants.SYSPARM_LIMIT:
                  case InstallBaseItemAPIConstants.SYSPARM_DEPTH:
                      if (gs.nil(pageParams))
                          pageParams = {};
                      pageParams[field] = queryParams[field];
                      break;

                  default:
                      if (gs.nil(returnMaps.queryParams))
                          returnMaps.queryParams = {};
                      returnMaps.queryParams[field] = queryParams[field];
              }
          }
      }
      returnMaps.pageParams = this._getPageParamValues(pageParams);
      return returnMaps;
  },

  _validatePageParamMap: function(pageParamMap) {
      if (!gs.nil(pageParamMap)) {
          var pageSize = pageParamMap.pageSize;
          if (!this._isInt(pageSize) || pageSize > InstallBaseItemAPIConstants.MAX_PAGE_SIZE || pageSize <= 0) {
              var msg = InstallBaseItemAPIConstants.API_MESSAGES.INVALID_PAGE_SIZE('' + pageSize);
              return InstallBaseItemAPIHelper.getErrorObject(msg, msg);
          }
          var startFrom = pageParamMap.startFrom;
          if (!this._isInt(startFrom) || startFrom < 0) {
              var offsetMsg = InstallBaseItemAPIConstants.API_MESSAGES.INVALID_PAGE_OFFSET('' + startFrom);
              return InstallBaseItemAPIHelper.getErrorObject(offsetMsg, offsetMsg);
          }
          var depth = pageParamMap.depth;
          if (!this._isInt(depth) || depth > InstallBaseItemAPIConstants.MAX_DEPTH || depth <= 0) {
              var depthMsg = InstallBaseItemAPIConstants.API_MESSAGES.INVALID_DEPTH('' + depth);
              return InstallBaseItemAPIHelper.getErrorObject(depthMsg, depthMsg);
          }
      }
      return true;
  },
  _isInt: function(value) {
      return !isNaN(value) &&
          parseInt(Number(value)) == value &&
          !isNaN(parseInt(value, 10));
  },

  _getPageParamValues: function(pageParamMap) {
      var pageSize = InstallBaseItemAPIConstants.DEFAULT_PAGE_SIZE;
      var depth = InstallBaseItemAPIConstants.DEFAULT_DEPTH;
      var startFrom = 0;
      if (!gs.nil(pageParamMap)) {
          startFrom = gs.nil(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_OFFSET]) ? 0 : parseInt(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_OFFSET]);
          pageSize = gs.nil(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_LIMIT]) ? InstallBaseItemAPIConstants.DEFAULT_PAGE_SIZE : parseInt(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_LIMIT]);
          depth = gs.nil(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_DEPTH]) ? InstallBaseItemAPIConstants.DEFAULT_DEPTH : parseInt(pageParamMap[InstallBaseItemAPIConstants.SYSPARM_DEPTH]);
      }

      var lastRecord = parseInt(startFrom) + parseInt(pageSize) + 1;

      var pageDetails = {
          "startFrom": startFrom,
          "pageSize": pageSize,
          "depth": depth,
          "lastRecord": lastRecord

      };


      return pageDetails;
  },
  _validateRequestParams: function(queryParams) {
      var paramMap = this._splitQueryAndPageParams(queryParams);
      var response = this._validatePageParamMap(paramMap.pageParams);
      if (!gs.nil(response.error))
          return response;
      return paramMap;
  },

  type: 'InstallBaseItemAPIBaseSNC'
};

Sys ID

0be554ed23112110e32f13d1d7bf658f

Offical Documentation

Official Docs: