Name

sn_smd.SMAPI

Description

No description available

Script

var SMAPI = Class.create();
SMAPI.SERVICE_CONTAINER_TABLE = "svc_container";

/**
*@param {String} modelId - The sys id of the model/service container to be loaded
*
*@return {SMSvcModel} A wrapped object representing the service model defined by modelID
*/
SMAPI.loadServiceModel = function(modelId) {
  if (gs.nil(modelId))
  	return null;
  
  try {
  	/* eslint-disable no-undef */
  	var svcContainer = sn_svcmod.ServiceContainerFactory.load(modelId);
  	/* eslint-enable no-undef */
  	
  	return new SMSvcModel(svcContainer);
  } catch(error) {
  	var displayMessage  = gs.getMessage('Failed to load service model with ID: {0}', modelId);
  	var internalMessage = 'Exception caught in SMAPI.loadServiceModel.';
  	throw SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, error);
  }	
};

/**
*@param {String} modelName - Identifier of the model/service container to be loaded
*
*@return {SMSvcModel} An wrapped object representing the service model defined by modelName
*/
SMAPI.loadServiceModelByName = function(modelName) {
  if (gs.nil(modelName))
  	return null;
  
  /* eslint-disable no-undef */
  var svcContainerList = sn_svcmod.ServiceContainerFactory.enumerate(modelName.trim());
  /* eslint-enable no-undef */

  if (gs.nil(svcContainerList) || svcContainerList.length == 0)
  	return null;

  return new SMSvcModel(svcContainerList[0]);
};

/**
*@param {String} name - Name of the new model/container to be created
*@param {String} description - An optional description to the new service model
*@return {SMSvcModel} A wrapped object representing the new service model that was created
*/
SMAPI.createServiceModel = function(name, description) {
  if (gs.nil(name)) {
  	var displayMessage  = gs.getMessage('Cannot create a model with an empty name');
  	throw SMErrorHelper.invalidArgumentError(displayMessage, '', error);
  }
  
  try {
  	/* eslint-disable no-undef */
  	var svcContainer = sn_svcmod.ServiceContainerFactory.createNew(name);
  	/* eslint-enable no-undef */
  	
  	if (!gs.nil(description))
  		svcContainer.setDescription(description);
  	
  	return new SMSvcModel(svcContainer);
  } catch(err) {
  	var displayMessage  = gs.getMessage('Failed to create service model with name: {0}', name);
  	var internalMessage = 'Exception caught in SMAPI.createServiceModel.';
  	throw SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, err);
  }
};

/**
*@return array of {SMSvcModel} objects representing all the service models/containers
*/
SMAPI.getServiceModels = function() {
  var serviceModels = [];
  var modelGR = new GlideRecord(SMAPI.SERVICE_CONTAINER_TABLE);
  modelGR.query();
  
  while(modelGR.next()) {
  	serviceModels.push(SMAPI.loadServiceModel(modelGR.getUniqueValue()));
  }
  
  return serviceModels;
};

/**
*@param {String} filter - an valid encoded query which filter the service model
*@return array of {SMSvcModel} objects representing all the service models/containers
*/
SMAPI.getFilteredServiceModels = function(filter) {
  var serviceModels = [];
  var modelGR = new GlideRecord(SMAPI.SERVICE_CONTAINER_TABLE);
  modelGR.addEncodedQuery(filter);
  modelGR.query();
  
  while(modelGR.next()) {
  	serviceModels.push(SMAPI.loadServiceModel(modelGR.getUniqueValue()));
  }
  
  return serviceModels;
};


/**
*@param {String} modelId - Id of the model/container 
*@param {String} layerkind - kind of layer (optional parameter)
*@param {String} layerKindIdentifier - kind identifier of the layer (optional parameter)
*@return array of {SMSvcLayer} objects representing the matching service layers in the model/container
*/
SMAPI.getServiceLayers = function(modelId, layerkind, layerKindIdentifier) {
  var serviceLayers = [];
  if (gs.nil(modelId))
  	return serviceLayers;
  
  try {
  		/* eslint-disable no-undef */
  		var svcContainer = sn_svcmod.ServiceContainerFactory.load(modelId);
  		/* eslint-enable no-undef */

  		if (gs.nil(svcContainer))
  			return serviceLayers;

  		var svcEnvironments = svcContainer.environments();

  		for (var i =0; i < svcEnvironments.length; i++) {
  			var svcLayers = svcEnvironments[i].layers();

  			if (gs.nil(svcLayers))
  				continue;

  			for (var j = 0; j < svcLayers.length; j++) {
  				if (gs.nil(svcLayers[j]))
  					continue;
  				
  				if (gs.nil(layerkind))
  					serviceLayers.push(new SMSvcLayer(svcLayers[j]));
  				else if (svcLayers[j].getKind() === layerkind) {
  					// If there's a layer kind and/or layer kind identifier is passed
  					// return only those matching layers,
  					if (gs.nil(layerKindIdentifier))
  						serviceLayers.push(new SMSvcLayer(svcLayers[j]));
  					else if (svcLayers[j].getKindIdentifier() === layerKindIdentifier)
  						serviceLayers.push(new SMSvcLayer(svcLayers[j]));
  				}
  			}
  		}
  	
  	return serviceLayers;
  	
  } catch(error) {
  	var displayMessage  = gs.getMessage('Failed to fetch layers for model ID: {0}', modelId);
  	var internalMessage = 'Exception caught in SMAPI.getServiceLayers.';
  	throw SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, error);
  }	
};

/**
*@param {String} layerId - Identifier of the layer to be loaded
*
*@return {SMSvcLayer} An object representing the service layer defined by layerId
*/
SMAPI.loadServiceLayer = function(layerId) {
  //loadLayer throws an exception so propagating up
  var layer = SMUtils.loadLayer(layerId);	
  return new SMSvcLayer(layer);
};

/**
* This method creates a service layer with new checkout version
*@param {String} modelId - A container where the layer is to be created
*@param {String} kind - one of the kinds (SERVICE_DEFINITION, SERVICE_STATE, PACKAGE_DEFINITION, PACKAGE_STATE) for the layer to be created
*@param {?String} identifier - A freeform text that identifies different layer of a same kind
*@param {?String} name - name of the new layer
*@param {?String} description - description of the new layer
*@param {?String} parentLayerId - A layer that the layer to be created depends upon
*
*@return {SMServiceLayer} An object representing the newly created service layer 
*/
SMAPI.createServiceLayer = function(modelId, kind, identifier, name, description, parentLayerId) {
  try {
  	var smModel = SMAPI.loadServiceModel(modelId);
  	var svcLayer = smModel.createLayer(kind, identifier, name, description, parentLayerId);
  	SMAPI.checkoutServiceDefinition({layerId:svcLayer.getId()});
  	return svcLayer;
  } catch(err) {
  	var displayMessage = gs.getMessage('Failed to create a dependent layer');
  	var internalMessage = 'Error in SMAPI.createDependentServiceLayer';
  	throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  }
};

//Remember to create VersionGenerator -- see SMVersionGeneratorFactory
SMAPI.createDependentServiceLayer = function(parentLayerId, kind, identifier, name, description, parentCheckpointId) {
  try {
  	var parentVersionObj = new SMSvcDefinition(parentLayerId, parentCheckpointId);
  	var parentLayer = SMAPI.loadServiceLayer(parentLayerId);
  	var smModel = parentLayer.getServiceModel();	
  	var childLayer = smModel.createLayer(kind, identifier, name, description, parentLayerId);
  	var childVersion = SMVersionGeneratorFactory.initialVersion(parentVersionObj.getVersion());

  	var childDao = childLayer.getDAO();
  	var chkout =  childDao.createCheckOut(null);
  	var tline = chkout.getTimeLine();

  	//Marking auto generated checkpoint for deleting as we will later clone anoter checkpoint for creating environment version
  	var prevChkPt = tline.getActiveCheckpoint();
  	var chkPt =  tline.cloneCheckpoint(parentVersionObj.getCheckpoint());

  	chkPt.setVersion(childVersion);
  	chkPt.setDependencies([parentVersionObj.getCheckpoint()]);
  	chkPt.flush();
  	tline.setActiveCheckpoint(chkPt);
  	tline.flush();

  	//prevChkPt is the auto generated checkpoint when the checkout timeline was crated for cloning the parent checkpoint onto it
  	//delete this dangling checkpoint here
  	prevChkPt.deleteRecord();

  	return childLayer;
  } catch(err) {
  	var displayMessage = gs.getMessage('Failed to create a dependent layer');
  	var internalMessage = 'Error in SMAPI.createDependentServiceLayer';
  	throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  }
};

SMAPI.deleteServiceLayer = function(layerId) {
  var smLayer = SMAPI.loadServiceLayer(layerId);
  smLayer.deleteLayer();
};

/**
*@param {String} layerId - Identifier of the layer for which versions are returned
*
*@return {Array<SMSvcDefinition>} A list of versions for layer with layerId
*/
SMAPI.getServiceDefinitions = function(layerId) {
  var layer = SMAPI.loadServiceLayer(layerId);
  return layer.getServiceDefinitions();
};

/**
*This gives active checkpoint and can be a checkedout or a checkedin version
*@param {String} layerId
*
*@return {SMSvcDefinition} A version object
*/
SMAPI.getLatestServiceDefinition = function(layerId) {
  return SMSvcDefinition.get({layerId:layerId});
};

/**
*@param {object} versionDTO that contains {layerId, checkpointId, checkoutId}.
* layerId is mandatory, 
* checkoutId is optional - if a checkoutId is provided the draft version defined by the DTO is checkedin. 
* If not provided latest version is used if possible. 
* checkpointId is not needed or must be the latest checkpoint of a draft version.
*
*@return {SMSvcDefinition} A new checked in (published) version object
*/
SMAPI.checkinServiceDefinition = function(versionDTO) {
  var versionObj = SMSvcDefinition.get(versionDTO);
  return versionObj.checkin();
};

/**
*@param {object} versionDTO that contains {layerId, checkpointId}.
* layerId is mandatory, 
* checkpointId - An id for the checked in version to be checked out. If not provided latest version is used if possible
*
*@return {SMSvcDefinition} A new checked out (draft) version object
*/
SMAPI.checkoutServiceDefinition = function(versionDTO) {
  var versionObj = SMSvcDefinition.get(versionDTO);
  return versionObj.checkout();
};

/**
*@param {object} versionDTO that contains {layerId, checkpointId, checkoutId}.
* layerId is mandatory, 
* checkoutId is optional - if a checkoutId is provided the draft version defined by the DTO is abandoned. 
* If not provided latest version is used if possible. 
* checkpointId is not needed or must be the latest checkpoint of a draft version.
*
*@return {SMSvcDefinition} A previous checked in version or null if there is none
*/
SMAPI.abandonServiceDefinition = function(versionDTO) {
  var versionObj = SMSvcDefinition.get(versionDTO);
  return versionObj.abandonCheckout();
};

/**
*@param {object} versionDTO that contains {layerId, checkpointId}.
* layerId is mandatory, 
* checkpointId - An id for the checked in version to be deleted. If not provided latest version is used if possible
*
*@return {SMSvcDefinition} A previous checked in version or null if there is none
*/
SMAPI.deleteServiceDefinition = function(versionDTO) {
  var versionObj = SMSvcDefinition.get(versionDTO);
  return versionObj.deleteChekpoint();
};

Sys ID

845608c9c3c22200e2ddb59af3d3aeda

Offical Documentation

Official Docs: