Name

sn_smd.SMSvcDefinition

Description

No description available

Script

var SMSvcDefinition = Class.create();

SMSvcDefinition.get = function(versionDTO) {
  return new SMSvcDefinition(versionDTO.layerId, versionDTO.checkpointId, versionDTO.checkoutId);
};

SMSvcDefinition.prototype = {
  layerId: null,
  checkpointId: null,
  checkoutId: null,
  version: null,
  model: null,
  _isCheckedout: false,
  _tline:null,
  _layerObj: null,
  _checkpointObj: null,
  _parentChkpoints: null, //dependencies of chkpoint of this version
  
  initialize: function(layerId, checkpointId, checkoutId) {
  	try {
  		this.layerId = layerId;		
  		this.checkoutId = checkoutId; 
  		this._layerObj =  SMUtils.loadLayer(layerId);

  		//If no checkpoint is passed in, go to the head; checkpoint just after layer creation can be null
  		if (gs.nil(checkpointId)) {
  			if(!gs.nil(checkoutId)) {
  				this._checkpointObj = SMUtils.loadCheckedoutActiveChkPt(this.getCheckedout());
  				this._isCheckedout = true;
  			} else {
  				//this is how we are getting head currently; this is a fallback in case the checpoint id is not defined.
  				this._checkpointObj = SMUtils.getActiveCheckpoint(layerId);
  			}
  		} else 
  			this._checkpointObj = SMUtils.loadCheckpoint(checkpointId);

  		if(!gs.nil(this._checkpointObj)) {
  			var dependencies = this._checkpointObj.getDependencies();
  			if(!gs.nil(dependencies) && !gs.nil(dependencies.length) && dependencies.length > 0)
  				this._parentChkpoints = dependencies;
  			this.checkpointId = this._checkpointObj.getSysId();
  			this._isCheckedout = this.isCheckedout();
  			var canWrite = false;
  			try {
  				this.checkCanWrite();
  				canWrite = true;
  			} catch(err) {
  				//proceed with canWrite as false;
  			}
  			this.model = this.getModel(this._isCheckedout && canWrite);
  		}
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to initialize service model version');
  		var internalMessage = 'Error in SMSvcDefinition.initialize()';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  	}
  },
  
  /**
  * return {SMSvcModel} - service container
  */
  getServiceModel: function() {
  	return new SMSvcModel(this.getLayer().getContainer());
  },
  
  getLayer: function() {
  	return this._layerObj;
  },
  
  getCheckpoint: function() {		
  	return this._checkpointObj;
  },
  
  getCheckpointId: function() {
  	return this.checkpointId;
  },
  
  getCheckoutId: function() {
  	return this.checkoutId;
  },
  
  getLayerId: function() {
  	return this.layerId;
  },
  
  isCheckedout: function() {
  	if(this._isCheckedout)
  		return true;
  	
  	try {
  		if(gs.nil(this.getCheckpoint()))
  			throw 'No checkpoint found';
  		
  		var chkOuts = SMUtils.getCheckouts(this.getLayer());
  		for(var i = 0; i < chkOuts.length; i++) {
  			var activeChkPt = SMUtils.loadCheckedoutActiveChkPt(chkOuts[i]);
  			if(activeChkPt.getSysId() === this.checkpointId) {
  				this.checkoutId = chkOuts[i].getSysId();
  				return true;
  			}
  		}
  	} catch (error) {
  		var displayMessage = gs.getMessage('Failed to determine checked-out status of a service model version');
  		var internalMessage = 'Error in SMSvcDefinition.isCheckedout()';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  	}
  	return false;
  },
  
  getModel: function(isEditable) {
  	try {
  		if(!gs.nil(this.model)) {
  			return this.model;
  		}
  		
  		if(isEditable) 
  			this.checkCanWrite();
  		else
  			this.checkCanRead();
  		
  		var chkPt = this.getCheckpoint();
  		if(gs.nil(chkPt))
  			return null;

  		this.model = isEditable ? chkPt.getEditableModel() : chkPt.getModel();

  		return this.model || null;
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to load service model');
  		var internalMessage = 'Error in SMSvcDefinition.getModel()';
  		var errObj =  SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  },
  
  getTimeLine: function() {
  	if(!gs.nil(this._tline))
  		return this._tline;
  	
  	try {
  		var chkPt = this.getCheckpoint();
  		if(gs.nil(chkPt))
  			throw 'No checkpoint found';
  		
  		this._tline = chkPt.getTimeLine();
  		return this._tline;
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to get a timeline');
  		var internalMessage = 'Error in SMSvcDefinition.getTimeline()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  },
  
  getCheckedout: function() {
  	if(gs.nil(this.checkoutId))
  		return null;
  	//use layer checkout id -- this.checkoutId
  	var checkedOutList = SMUtils.getCheckouts(this.getLayer());
  	for(var i = 0; i < checkedOutList.length; i++) {
  		if(checkedOutList[i].getSysId() === this.checkoutId)
  			return checkedOutList[i];
  	}
  	
  	var displayMessage = gs.getMessage('Failed to get a checked out model');
  	var internalMessage = 'Error in SMSvcDefinition.getCheckedout()';
  	var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, null);
  	errObj.setErrorLevel(SMErrorLevel.FATAL);
  	throw errObj;
  },
  
  //@Deprecated -- use shorter version getDTO instead
  getVersionDTO: function() {
  	return this.getDTO();
  },
  
  getDTO: function() {
  	var obj = {};
  	obj.version = this.getVersion();
  	obj.checkpointId = this.checkpointId;
  	obj.checkoutId = this.checkoutId;
  	obj.layerId = this.layerId;
  	return obj;
  },
  
  getVersion: function() {
  	return gs.nil(this.getCheckpoint()) ? '' : this._checkpointObj.getVersion();
  },
  
  checkin: function() {
  	try {	
  		this.checkCanWrite();
  
  		var activeCheckpoint = this.getCheckedout().getTimeLine().getActiveCheckpoint();
  		var model = activeCheckpoint.getEditableModel();			
  		model = this._addClusterDefinitionsFromConstraints(model);
  		this.createActiveCheckpoint(model);
  		
  		var chkPt = this.getCheckedout().checkIn();
  		chkPt.setVersion(this.getVersion());
  		
  		if(!gs.nil(this._parentChkpoints))
  			chkPt.setDependencies(this._parentChkpoints);
  		chkPt.flush();
  		
  		return new SMSvcDefinition(this.layerId, chkPt.getSysId(), null);

  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to publish the service model');
  		var internalMessage = 'Error in SMSvcDefinition.checkin()';
  		var errObj = SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  }, 
  
  _addClusterDefinitionsFromConstraints: function(model) {
  	// Get all the elements and create a cluster definition for them
  	var elements = model.elements();
  	for (var i = 0; i < elements.length; i++) {
  		var element = elements[i];
  		if (element.isTopLevelElement()) {
  			// TODO: Discuss cluster ci type
  			var smElem = new SMElement(element);
  			var cardinality = smElem.getClusterCardinalityFromConstraints();
  			var clusterDefinition = element.getCluster();
  			if (gs.nil(clusterDefinition) && cardinality > 0) {
  				clusterDefinition = model.createCluster('cmdb_ci_cluster');
  				// Name of the cluster will be element name + '_cluster'. Ex: For tomcat it will be tomcat_cluster
  				clusterDefinition.setName(element.getName() + '_cluster');
  			} 
  			
  			if (cardinality == 0) {
  				if (!gs.nil(clusterDefinition)) {
  					clusterDefinition.remove();
  					model.propagateCluster();	
  				}
  				continue;
  			} 
  			
  			clusterDefinition.setCardinality(cardinality);
  			smElem.setCluster(clusterDefinition);
  			smElem.setClusterDefinitionOnChildren(clusterDefinition);
  			smElem.setClusterDefinitionOnImplementedEndpoints(clusterDefinition);
  		}
  	}
  	model.flushChanges();
  	return model;
  },
  
  checkout: function() {
  	var layer = this.getLayer();
  	try {
  		this.checkCanWrite(true);
  		
  		var chkout =  layer.createCheckOut(this.getCheckpoint());
  		if (!gs.nil(chkout)) {
  			var chkPt = chkout.getTimeLine().getActiveCheckpoint();
  			var version = SMVersionGeneratorFactory.get(this.getLayer().getKindIdentifier()).generate(this.getLayer());
  			chkPt.setVersion(version);
  			if(!gs.nil(this._parentChkpoints))
  				chkPt.setDependencies(this._parentChkpoints);
  			chkPt.flush();

  			return new SMSvcDefinition(this.layerId, chkPt.getSysId(), chkout.getSysId());
  		}
  		throw 'Valid check out not found';

  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to checkout the service model');
  		var internalMessage = 'Error in SMSvcDefinition.checkout()';
  		var errObj = SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  },
  
  abandonCheckout: function() {
  	var chkout = this.getCheckedout();
  	try {	
  		this.checkCanWrite();
  		
  		chkout.abandon();
  		var activeChkPt = this.getLayer().getActiveCheckpoint();
  		return gs.nil(activeChkPt) ? null : new SMSvcDefinition(this.layerId, activeChkPt.getSysId(), null);
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to abandon checked out model');
  		var internalMessage = 'Error in SMSvcDefinition.abandonCheckout()';
  		var errObj = SMErrorHelper.createJavaAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  	return true;		
  },
  
  deleteChekpoint: function() {
  	try {
  		this.checkCanWrite(true);
  		
  		var chkPt = this.getCheckpoint();
  		if(gs.nil(chkPt))
  			throw 'Checkpoint not found';
  		
  		var dependents = chkPt.getDependents();
  		if(!gs.nil(dependents) && !gs.nil(dependents.length) && dependents.length > 0)
  			this._deleteDependents(dependents);

  		var nextChkPt = null;
  		var hasActiveChkPt = this.hasActiveCheckpoint();
  		if(hasActiveChkPt) 
  			nextChkPt = chkPt.getPreviousCheckpoint();
  		if(gs.nil(nextChkPt))
  			nextChkPt = SMUtils.getLatestActiveChkPtFromChkouts(this.layerId);

  		chkPt.deleteRecord();

  		if(!gs.nil(nextChkPt)) {
  			var tline = nextChkPt.getTimeLine();
  			tline.setActiveCheckpoint(nextChkPt);
  			tline.flush();
  			return new SMSvcDefinition(this.layerId, nextChkPt.getSysId(), null);
  		}

  		return hasActiveChkPt ? null : this;		
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to delete the service model version');
  		var internalMessage = 'Error in SMSvcDefinition.deleteChekpoint()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  	
  },
  
  hasActiveCheckpoint: function() {
  	var chkPt = this.getCheckpoint();
  	if(gs.nil(chkPt))
  		return false;
  	
  	var activeChkPt = chkPt.getTimeLine().getActiveCheckpoint();
  	
  	return (!gs.nil(activeChkPt) && (chkPt.getSysId() === activeChkPt.getSysId()));
  },
  
  createActiveCheckpoint: function(model) {
  	var tline = this.getTimeLine();
  	try {
  		var version = SMVersionGeneratorFactory.get(this.getLayer().getKindIdentifier()).generate(this.getLayer());
  		var chkPt = tline.createNewCheckpoint(model);			
  		chkPt.setVersion(version);
  		if(!gs.nil(this._parentChkpoints))
  			chkPt.setDependencies(this._parentChkpoints);
  		chkPt.flush();
  		tline.setActiveCheckpoint(chkPt);
  		tline.flush();
  		return chkPt;
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to create and activate new checkpoint');
  		var internalMessage = 'Error in SMSvcDefinition.createActiveCheckpoint()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  },
  
  //Create a new checkpoint using the given model, if model is not provided use the model for this versionObject
  commit: function(model) {
  	try {
  		var chkPt = this.createActiveCheckpoint(model || this.model);
  		return new SMSvcDefinition(this.layerId, chkPt.getSysId(), this.checkoutId);
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to create and get a new version');
  		var internalMessage = 'Error in SMSvcDefinition.getNewVersion';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },
  
  //@deprecated
  getNewVersion: function(model) {
  	return this.commit(model);
  },
  
  getElements: function(editable) {
  	var model = this.getModel(editable);		
  	var elems = model.elements();
  	var smElems = [];
  	for(var i = 0; i < elems.length; i++) {
  		smElems.push(new SMElement(elems[i]));
  	}
  	return smElems;
  },
  
  /** @returns {SMElement} */
  getElement: function(elementId, editable) {
  	if (editable)
  		this._ensureEditableModel();
  	var elem = this.model.findElement(elementId);
  	var smElem = gs.nil(elem) ? null : new SMElement(elem);
  	return smElem;
  },
  
  //by default inner node type relation is created if no relType specified for an containing element
  addElement: function(ciType, elementName, parentElementId, relType) {
  	try {
  		this._ensureEditableModel();
  		
  		var parentElem;
  		if (!gs.nil(parentElementId)) {
  			parentElem = this.model.findElement(parentElementId);
  			if (gs.nil(parentElem)) {
  				throw 'Parent element with id ' + parentElementId + ' does not exist';
  			}
  		}

  		var elem = this.model.createElement(ciType);
  		elem.setName(elementName || ciType);

  		if (!gs.nil(parentElem)) {
  			this.model.createRelation(parentElem, elem, relType || SMConstants.INNER_NODE_RELATION);
  		}

  		return new SMElement(elem);
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to add an element');
  		var internalMessage = 'Error in SMSvcDefinition.addElement';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },
  
  removeElement: function(elementId) {		
  	try {
  		var smElem = this.getElement(elementId, true);
  		if (gs.nil(smElem)) 
  			throw 'An element to be deleted not found';
  		
  		smElem.remove();
  	}
  	catch(error) {
  		var displayMessage = gs.getMessage('Failed to remove an element');
  		var internalMessage = 'Error in SMSvcDefinition.removeElement';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  	}
  },
  
  _ensureEditableModel: function() {
  	this.model = this.getModel(true);
  	if(gs.nil(this.model) || !this.model.canEdit()) {
  		throw 'Editable model not found';
  	}
  },
  
  checkCanCreate: function() {
  	this._checkPermission(SMSecurityManager.CREATE);
  },
  
  checkCanRead: function() {
  	this._checkPermission(SMSecurityManager.READ);
  },
  
  checkCanWrite: function(noCheckout) {
  	this._checkPermission(SMSecurityManager.WRITE);	
  	if (!noCheckout && !this.isCheckedout())
  		throw 'Valid check out not found';
  },
  
  checkCanDelete: function() {
  	this._checkPermission(SMSecurityManager.DELETE);
  },
  
  checkCanAdministerSecurity: function() {
  	this._checkPermission(SMSecurityManager.ADMINISTER_SECURITY);
  },
  
  /**
   *@param {string} sourceId - Id of source element
   *@param {string} targetId - Id of target element
   *@param {string} relType - relationship type
   *@return {?SMRelationship} An element representing a relationship object.
   */
  getRelationship : function(sourceId, targetId, relType) {
  	try {
  		var relations = this.getRelationshipsBySource(sourceId, relType);

  		for (var i = 0; i <relations.length(); i++){
  			if(relations[i].getTarget().getStableId() == targetId){
  				return relations[i];
  			}
  		}
  		return null;
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to get a relationship');
  		var internalMessage = 'Error in SMSvcDefinition.getRelationship';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },

  /**
   *@param {string} sourceId - Id of source element
   *@param {string} relType - Id of source element
   *@return {!Array<!SMRelationship>} A list of elements representing a relationship object.
   */
  getRelationshipsBySource : function(sourceId, relType) {
  	try {
  		var model = this.getModel(false); //this does checkCanRead();
  		if(gs.nil(model)) {
  			throw 'No readable model found for a relationship retrieve';
  		}

  		var sourceElem;
  		if (!gs.nil(sourceId)) {
  			sourceElem = model.findElement(sourceId);
  			if (gs.nil(sourceElem)) {
  				throw 'Source element with id ' + sourceId + ' does not exist';
  			}
  		}

  		var relations = sourceElem.filteredRelations(relType);
  		if(gs.nil(relations)) {
  			throw 'No relationship list object found for type: ' + relType;
  		}
  		var smRelationships = [];
  		for(var i = 0; i < relations.length; i++){
  			smRelationships.push(new SMRelationship(relations[i]));
  		}
  		return smRelationships;
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to get a list of relationships');
  		var internalMessage = 'Error in SMSvcDefinition.getRelationshipsBySource';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },
  
  /**
    * Returns ALL relationship for the current model.
    * @return {!Array<!SMRelationship>} A list of elements representing a relationship object.
    */
  getRelationships : function(){
  	try {
  		var model = this.getModel(false); //this does checkCanRead();
  		if(gs.nil(model)) {
  			throw 'No readable model found for a relationship retrieve';
  		}
  		var relations = model.relations();
  		var smRelationships = [];
  		
  		for(var i = 0; i < relations.length; i++){
  			smRelationships.push(new SMRelationship(relations[i]));
  		}
  		return smRelationships;
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to get the relationship list');
  		var internalMessage = 'Error in SMSvcDefinition.getRelationships';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}	
  },
  
  /** Removes a relationship from the model.
   *@param {string} relationId - Id of relationship
   */
  removeRelationship : function(relationId) {
  	try {
  		var relations = this.getRelationships();
  		for (var i = 0; i <relations.length; i++){
  			if(relations[i].getId() == relationId){
  				relations[i].getDAO().remove();
  				return;
  			}
  		}
  		throw 'No relationship found with the element with id: ' + relationId + ' was found';
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to remove a relationship');
  		var internalMessage = 'Error in SMSvcDefinition.removeRelationship';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },
  
  /** Adds a relationship between the specified objects.
  *@param {string} sourceId - Id of source element
  *@param {string} targetId - Id of target element
  *@param {string} relType - relationship type
  *@return {!SMRelationship} An element representing a relationship object.
  */
  addRelationship : function(sourceId, targetId, relType) {
  	try {
  		var model = this.getModel(true);
  		var sourceElem;
  		if (!gs.nil(sourceId)) {
  			sourceElem = model.findElement(sourceId);
  			if (gs.nil(sourceElem)) {
  				throw 'Source element with id ' + sourceId + ' does not exist';
  			}
  		}
  		
  		var targetElem;
  		if (!gs.nil(targetId)) {
  			targetElem = model.findElement(targetId);
  			if (gs.nil(sourceElem)) {
  				throw 'Target element with id ' + targetId + ' does not exist';
  			}
  		}
  		
  		var relation = sourceElem.createRelation(targetElem, relType);
          return new SMRelationship(relation);
  	} catch(err) {
  		var displayMessage = gs.getMessage('Failed to add a relationship');
  		var internalMessage = 'Error in SMSvcDefinition.addRelationship';
  		throw SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, err);
  	}
  },
  
  _checkPermission: function(operation) {
  	var securityManager = new SMSecurityManager();
  	var secCtxString = securityManager.getLayerContextId(this.getLayer());
  	if(!securityManager.checkPermission(secCtxString, this.layerId, operation)) {
  		var displayMessage = gs.getMessage('Cannot perform {0}: Permission denied', operation);
  		var internalMessage = 'Error in SMSvcDefinition._checkPermission()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, null);
  		errObj.setErrorLevel(SMErrorLevel.FATAL);
  		throw errObj;
  	}
  },
  
  _deleteDependents: function(dependents) {		
  	try {
  		for(var i = 0; i < dependents.length; i++) {
  			var currVersionObj = null;
  			var newVersionObj = null;
  			var dependent = dependents[i];
  			var tmpTimeLine = dependent.getTimeLine();
  			var tmpLayerId = tmpTimeLine.getLayer().getSysId();
  			var chkout = SMUtils.getCheckedOutOfTimeLine(tmpTimeLine);
  			
  			if(!gs.nil(chkout)) {
  				currVersionObj = new SMSvcDefinition(tmpLayerId, dependent.getSysId(), chkout.getSysId());	
  				newVersionObj = currVersionObj.abandonCheckout();
  			} else {
  				currVersionObj = new SMSvcDefinition(tmpLayerId, dependent.getSysId(), null);				
  				newVersionObj = currVersionObj.deleteChekpoint();
  			}
  			
  			if (gs.nil(newVersionObj)) 
  				SMAPI.deleteServiceLayer(tmpLayerId);
  		}	
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to delete dependent checkpoints');
  		var internalMessage = 'Error in SMSvcDefinition._deleteDependents()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.ERROR);
  		throw errObj;
  	}
  },
  
  /**
  * This will add a constraint of type IConstraintDefinitionForNewResource
  */
  addNewResourceConstraintToElement : function(ciType, elementId){
  	try{
  		if(ciType && elementId){
  			var elem = this.model.findElement(elementId);
  			if(gs.nil(elem)){
  				throw 'element with id ' + elementId + ' was not found.';
  			}
  			var resourceConstraint = this.model.createConstraintForNewResource(ciType);
  			elem.bindConstraint(resourceConstraint);
  			return resourceConstraint;
  		} else {
  			throw 'ciType and elementId are required';
  		}
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to add constraint');
  		var internalMessage = 'Error in SMSvcDefinition.addConstraintNewResourceToElement()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.ERROR);
  		throw errObj;
  	}
  },
  
  /**
  * This will remove any kind of constraint
  */
  removeConstraint : function(elementId, constraintId){
  	try{
  		if(elementId){
  			var elem = this.model.findElement(elementId);
  			if(gs.nil(elem)){
  				throw 'element with id ' + elementId + ' was not found.';
  			}
  			var constraints = elem.constraintBindings();
  			for(var i=0; i< constraints.length; i++){
  				if(constraints[i].getStableId() == constraintId){
  					elem.unbindConstraint(constraints[i]);
  					return;
  				}
  			}
  			throw 'constraint to delete not found';
  		} else {
  			throw 'constraintId and elementId are required';
  		}
  	} catch(error) {
  		var displayMessage = gs.getMessage('Failed to remove constraint');
  		var internalMessage = 'Error in SMSvcDefinition.removeConstraint()';
  		var errObj = SMErrorHelper.createScriptAPIError(displayMessage, internalMessage, error);
  		errObj.setErrorLevel(SMErrorLevel.ERROR);
  		throw errObj;
  	}
  },
  
  type: 'SMSvcDefinition'
};

Sys ID

410d63aec3752200e2ddb59af3d3ae54

Offical Documentation

Official Docs: