Name

global.PDDiagramActivityRepository

Description

No description available

Script

var PDDiagramActivityRepository = Class.create();
PDDiagramActivityRepository.prototype = {
  initialize: function() {},
  type: 'PDDiagramActivityRepository',

  insertActivity: function(fields) {
      fields = fields || {};
      var gr = new GlideRecord(PDDiagramConstants.TABLES.PD_ACTIVITY);
      gr.initialize();
  	var processDefinition = fields['processDefinition'];
  	var activityDefinition = fields['activityDefinition'];
  	var label = fields['label'];
  	var lane = fields['lane'];
  	if (!processDefinition || !activityDefinition || !label || !lane)
  		throw (gs.getMessage(
  			'Missing one or more of required fields: processDefinition, activityDefinition, label, lane'));
  	// the user can optionally pass in a sysId to hardcode the record to
      var sysId = fields['sysId'];
      if (sysId)
          gr.setNewGuidValue(sysId);

      this._setFieldsOnGr(fields, gr, false);

      var insertedId = gr.insert();

      if (!insertedId) {
          var errorRecordId = sysId || '';
          throw gs.getMessage('Unable to insert activity {0}: {1}', [errorRecordId, gr.getLastErrorMessage()]);
      }

      var insertedGr = this.get(insertedId);

      // an activity record has to be inserted and saved first before updating its inputs 
      // because inputs don't exist on the activity until the activity has been inserted and the activity definition is set. 
      // The inputs are inherited from the activity definition, so we don't have them until the activity definition is set.
      if (fields.inputs)
          this._handleInputChanges(fields.inputs, insertedGr);

      return this._getActivityFromGR(insertedGr);
  },

  updateActivity: function(fields) {
      fields = fields || {};

      var sysId = fields['sysId'];

      if (!sysId)
          throw (gs.getMessage('Missing required field: sysId'));

      var activityGr = this.get(sysId);

      if (!activityGr)
          throw (gs.getMessage('Unable to find activity with id: {0}', sysId));

      this._setFieldsOnGr(fields, activityGr, true);

      if (!activityGr.update())
          throw gs.getMessage('Unable to update activity {0}: {1}', [sysId, activityGr.getLastErrorMessage()]);

      return this._getActivityFromGR(activityGr);
  },

  // activitiesStr: a string of activity Ids separated by ,
  deleteActivities: function(activitiesStr) {
      if (!activitiesStr || activitiesStr.length === 0)
          throw (gs.getMessage('No activity to delete'));

      var gr = new GlideRecord(PDDiagramConstants.TABLES.PD_ACTIVITY);
      gr.addQuery('sys_id', 'IN', activitiesStr);
      gr.query();
      gr.deleteMultiple();
  },

  get: function(sysId) {
      var gr = new GlideRecord(PDDiagramConstants.TABLES.PD_ACTIVITY);
      gr.get(sysId);

      if (gr.isValidRecord())
          return gr;

      return null;
  },

  _setFieldsOnGr: function(fields, gr, includeInputs) {
      for (var fieldName in fields) {
          var snakeCaseFieldName = PDDiagramUtils.camelcaseToSnakecase(fieldName);

          switch (snakeCaseFieldName) {
              case PDDiagramConstants.FIELDS.SYS_ID: //we never want to set the sys id of an update
                  continue;
              case PDDiagramConstants.FIELDS.INPUTS:
                  if (includeInputs) {
                      this._handleInputChanges(fields[fieldName], gr);
                      break;
                  } else
                      continue;
              case PDDiagramConstants.FIELDS.TYPE_VALS:
                  this._handleTypeValChanges(fields[fieldName], gr);
                  break;
              case PDDiagramConstants.FIELDS.START_RULE:
                  this._handleStartRuleChange(fields[fieldName], gr);
                  break;
              default:
                  gr.setValue(snakeCaseFieldName, fields[fieldName]);
          }
      }
  },

  // The following two methods (_handleTypeValChanges and _handleInputChanges)
  // are nearly identical and should be combined in the future
  
  _handleTypeValChanges: function(typeVals, activityGr) {
  	var glideElement = activityGr.getElement(PDDiagramConstants.FIELDS.TYPE_VALS);
  	var variablesRecord = glideElement.getVariablesRecord();

  	typeVals.forEach(function(typeVal) {
  		variablesRecord.setValue(typeVal.variableName, typeVal.variableValue || '');
  		var ge = glideElement[typeVal.variableName];
  		ge.setValueMapping(typeVal.variableMapping || '');
  	});

  	variablesRecord.update();
  	activityGr.update();
  },

  _handleInputChanges: function(inputs, activityGr) {
      if (!((inputs || {}).variables || {}).length)
          return;

  	var glideElement = activityGr.getElement(PDDiagramConstants.FIELDS.INPUTS);
  	var variablesRecord = glideElement.getVariablesRecord();
      
  	inputs.variables.forEach(function(inputVar) {
  	    variablesRecord.setValue(inputVar.variableName, inputVar.variableValue || '');
  	    var ge = glideElement[inputVar.variableName];
  	    ge.setValueMapping(inputVar.variableMapping || '');
      });

  	variablesRecord.update();
  	activityGr.update();
  },

  getActivitiesByProcessDefinition: function(processDefinitionId) {
      if (!processDefinitionId)
          throw (gs.getMessage('Missing required parameter: processDefinitionId'));

      var gr = new GlideRecord(PDDiagramConstants.TABLES.PD_ACTIVITY);
      gr.addQuery(PDDiagramConstants.FIELDS.PROCESS_DEFINITION, processDefinitionId);
      gr.query();

      var activities = [];
      while (gr.next()) {
          activities.push(this._getActivityFromGR(gr));
      }
      return activities;
  },

  _handleStartRuleChange: function(startRulePayload, gr) {
      var definition = startRulePayload.definition;
      if (definition !== PDDiagramConstants.START_RULES.AFTER_ACTIVITIES)
          throw gs.getMessage('Activity must have a start rule of After Activities');
      gr.setValue(PDDiagramConstants.FIELDS.START_RULE, definition);
      var activities = (startRulePayload.vars || {}).activities || [];
      gr.getElement(PDDiagramConstants.FIELDS.START_RULE_VAR_AFTER_ACTIVITIES).setValue(activities);
      var branches = (startRulePayload.vars || {}).branches || [];
      branches = branches
          .map(function(branch) {
              return branch.activityId + '.' + branch.branchId;
          })
          .join(',');
      gr.getElement(PDDiagramConstants.FIELDS.START_RULE_VAR_BRANCHES).setValue(branches);
  },

  _getInputArrayFromGR: function(gr) {
      var inputs = [];

      var activityInputs = gr.getElement('inputs').getVariablesRecord();

      Object.keys(activityInputs).forEach(function(input) {
          if (
  			!input || 
  			input === PDDiagramConstants.FIELDS.SYS_META || 
  			input === PDDiagramConstants.FIELDS.SYS_ID
  		)
              return;

          var inputVariable = activityInputs[input];
          var internalType = inputVariable.getED().getInternalType();
          var inputValue = inputVariable.getValue() || ''; // DEF0348150 Inconsistent empty values
          var displayValue = inputVariable.getDisplayValue();

          // DEF0348150 Inconsistent empty values
          if (internalType == 'boolean')
          inputValue = displayValue;

          var newInputVar;

          newInputVar = {
              value: inputValue,
              variableValue: inputValue,
              displayValue: displayValue,
              internalType: internalType,
              label: inputVariable.getLabel(),
              variableName: inputVariable.getName(),
              variableMapping: inputVariable.getValueMapping(),
              canRead: inputVariable.canRead(),
              canWrite: inputVariable.canWrite(),
              isMandatory: inputVariable.getED().isMandatory(),
          };

          inputs.push(newInputVar);
      });
      return {
          variables: inputs
      };
  },

  _getActivityFromGR: function(gr) {
      var FIELDS = PDDiagramConstants.FIELDS;
      var inputs = this._getInputArrayFromGR(gr);

      var geStartRuleVarsActivities =
          gr.getElement(PDDiagramConstants.FIELDS.START_RULE_VAR_AFTER_ACTIVITIES);
      var startRuleVarValueActivities =
          geStartRuleVarsActivities && geStartRuleVarsActivities.getValue();
      if (startRuleVarValueActivities)
          startRuleVarValueActivities = geStartRuleVarsActivities.split(',');

      var geStartRuleVarsBranches =
          gr.getElement(PDDiagramConstants.FIELDS.START_RULE_VAR_BRANCHES);
      var startRuleVarValueBranches =
          geStartRuleVarsBranches && geStartRuleVarsBranches.getValue();
      if (startRuleVarValueBranches)
          startRuleVarValueBranches = startRuleVarValueBranches.split(',')
          .map(function(branch) {
              var splitBranch = branch.split('.');
              return {
                  activityId: splitBranch[0],
                  branchId: splitBranch[1]
              };
          });

      return {
          sys_id: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.SYS_ID),
          label: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.LABEL),
          coordinates: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.COORDINATES),
          swim_lane: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.SWIM_LANE),
          lane: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.LANE),
          startRule: {
              definition: gr.getValue(FIELDS.START_RULE),
              vars: {
                  activities: startRuleVarValueActivities || [],
                  branches: startRuleVarValueBranches || []
              }
          },
          inputs: inputs,
          active: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.ACTIVE),
          name: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.NAME),
          description: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.DESCRIPTION),
          activity_definition: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.ACTIVITY_DEFINITION),
          process_definition: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.PROCESS_DEFINITION),
          sys_created_on: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.SYS_CREATED_ON),
          sys_updated_on: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.SYS_UPDATED_ON),
          condition_to_run: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.CONDITION_TO_RUN),
  		order: PDDiagramUtils.getFieldReturnValue(gr, FIELDS.ORDER)
      };
  }
};

Sys ID

7b1a76e277d38110033a902f8c5a99be

Offical Documentation

Official Docs: