Name

sn_flow_diagram.FlowDiagramHelper

Description

No description available

Script

var FlowDiagramHelper = Class.create();
FlowDiagramHelper.prototype = {
  initialize: function() {},

  type: 'FlowDiagramHelper'
};

var UUID_LENGTH = 36;
var FIRST_DASH = 8;
var SECOND_DASH = 13;
var THIRD_DASH = 18;
var FOURTH_DASH = 23;

FlowDiagramHelper.isValidUuid = function(uuid) {
  return uuid &&
      uuid.length === UUID_LENGTH &&
      uuid.charAt(FIRST_DASH) === '-' &&
      uuid.charAt(SECOND_DASH) === '-' &&
      uuid.charAt(THIRD_DASH) === '-' &&
      uuid.charAt(FOURTH_DASH) === '-';
};

FlowDiagramHelper.reverseUuid = function(uuid) {
  var newUuid = uuid;
  if (FlowDiagramHelper.isValidUuid(newUuid)) {
      newUuid = FlowDiagramHelper.removeUiUniqueIdentifierDashes(newUuid);
      newUuid = newUuid.split('').reverse().join('');
      newUuid = FlowDiagramHelper.addUiUniqueIdentifierDashes(newUuid);
      return newUuid;
  } else {
      return FlowDiagramHelper.addUiUniqueIdentifierDashes(sn_flow.FlowDesigner.getGeneratedGuid());
  }
};

// should only process 0-9, a-f characters (hexadecimal)
FlowDiagramHelper.addOneToFirstLastHexadecimal = function(str) {
  if (str && str.length >= 2) {
      var first = str.substring(0, 1);
      var last = str.substring(str.length - 1);
      str = FlowDiagramHelper.addOneToHexadecimal(first) + str.substring(1, str.length - 1) + FlowDiagramHelper.addOneToHexadecimal(last);
  }
  return str;
};

// should only process 0-9, a-f characters (hexadecimal)
FlowDiagramHelper.addOneToHexadecimal = function(str) {
  var newStr;
  if (str === 'f') {
      newStr = '0';
  } else if (str === '9') {
      newStr = 'a';
  } else {
      newStr = String.fromCharCode(str.charCodeAt(0) + 1);
  }
  return newStr;
};

// Adds char codes of a string to a hex
FlowDiagramHelper.addStringToUuid = function(str, uuid) {
  if (typeof str !== 'string') {
      throw 'Invalid string given to addStringToUuid: ' + str;
  }
  if (!FlowDiagramHelper.isValidUuid(uuid)) {
      throw 'Invalid uuid given to addStringToUuid: ' + uuid;
  }

  // Create char codes based on our 'key' str
  var charCodeStr = '';
  for (var i = 0; i < str.length; i++) {
      charCodeStr += str.charCodeAt(i);
  }
  var charCodeInt = parseInt(charCodeStr);

  // Get the last eight of the old uuid
  var uuidWithoutDashes = FlowDiagramHelper.removeUiUniqueIdentifierDashes(uuid);
  var lastEightUuid = uuidWithoutDashes.substring(uuidWithoutDashes.length - 8, uuidWithoutDashes.length);
  lastEightUuid = parseInt(lastEightUuid, 16);

  // Add the last eight of the old uuid to the char codes we made earlier
  var newUuid = (charCodeInt + lastEightUuid).toString(16);
  if (newUuid.length > uuidWithoutDashes.length) {
      newUuid = newUuid.substring(0, uuidWithoutDashes.length);
  }

  // Create a new uuid, injecting the new uuid into the old uuid
  newUuid = uuidWithoutDashes.substring(0, uuidWithoutDashes.length - newUuid.length) + newUuid;

  // Make sure to add in dashes again before returning
  return FlowDiagramHelper.addUiUniqueIdentifierDashes(newUuid);
};

// sort the array "d" by "order" value 
// this sort supports arrayPosition value with dots (e.g. 1.2.33)
// sortByArrayPosition(array); // sort by asc
// sortByArrayPosition(array "desc"); sort by desc
FlowDiagramHelper.sortByArrayPosition = function(d, order) {
  var sort = {
          asc: function(a, b) {
              var l = 0,
                  m = Math.min(a.value.length, b.value.length);
              while (l < m && a.value[l] === b.value[l]) {
                  l++;
              }
              return l === m ? a.value.length - b.value.length : a.value[l] - b.value[l];
          },
          desc: function(a, b) {
              return sort.asc(b, a);
          }
      },

      // temporary array holds objects with position and sort-value
      mapped = d.map(function(el, i) {
          return {
              index: i,
              value: el.arrayPosition.toString().split('.').map(Number)
          };
      });

  // sorting the mapped array containing the reduced values
  mapped.sort(sort[order] || sort.asc);

  // container for the resulting order
  return mapped.map(function(el) {
      return d[el.index];
  });
};

FlowDiagramHelper.sortByDepth = function(d, depth) {
  var sort = {
          asc: function(a, b) {
              var l = 0,
                  m = Math.min(a.value.length, b.value.length);
              while (l < m && a.value[l] === b.value[l]) {
                  l++;
              }
              return l === m ? a.value.length - b.value.length : a.value[l] - b.value[l];
          },
          desc: function(a, b) {
              return sort.asc(b, a);
          }
      },

      // temporary array holds objects with position and sort-value
      mapped = d.map(function(el, i) {
          return {
              index: i,
              value: el.depth.toString().split('.').map(Number)
          };
      });

  // sorting the mapped array containing the reduced values
  mapped.sort(sort[depth] || sort.asc);

  // container for the resulting order
  return mapped.map(function(el) {
      return d[el.index];
  });
};

FlowDiagramHelper.sortByCustomOrder = function(d, order) {
  var sort = {
          asc: function(a, b) {
              var l = 0,
                  m = Math.min(a.value.length, b.value.length);
              while (l < m && a.value[l] === b.value[l]) {
                  l++;
              }
              return l === m ? a.value.length - b.value.length : a.value[l] - b.value[l];
          },
          desc: function(a, b) {
              return sort.asc(b, a);
          }
      },

      // temporary array holds objects with position and sort-value
      mapped = d.map(function(el, i) {
          return {
              index: i,
              value: el.customOrder.toString().split('.').map(Number)
          };
      });

  // sorting the mapped array containing the reduced values
  mapped.sort(sort[order] || sort.asc);

  // container for the resulting order
  return mapped.map(function(el) {
      return d[el.index];
  });
};

FlowDiagramHelper.hasProperty = function(object, key) {
  if (object && typeof object === "object" && key !== undefined && key !== null && Object.prototype.hasOwnProperty.call(object, key)) {
      return true;
  }
  return false;
};

// removes dashes from str (should be uuid formatted)
FlowDiagramHelper.removeUiUniqueIdentifierDashes = function(str) {
  var newUuid = str;
  if (typeof newUuid === 'string') {
      newUuid = newUuid.split('');
      newUuid.splice(FOURTH_DASH, 1);
      newUuid.splice(THIRD_DASH, 1);
      newUuid.splice(SECOND_DASH, 1);
      newUuid.splice(FIRST_DASH, 1);
      newUuid = newUuid.join('');
  }

  return newUuid;
};

// inserts dashes to str (should be uuid formatted)
FlowDiagramHelper.addUiUniqueIdentifierDashes = function(str) {
  str = FlowDiagramHelper.insertNewStringAtIndex(str, 20, "-");
  str = FlowDiagramHelper.insertNewStringAtIndex(str, 16, "-");
  str = FlowDiagramHelper.insertNewStringAtIndex(str, 12, "-");
  str = FlowDiagramHelper.insertNewStringAtIndex(str, 8, "-");
  return str;
};

FlowDiagramHelper.insertNewStringAtIndex = function(existing, i, insert) {
  if (i >= 0 && i < existing.length)
      return existing.slice(0, i) + insert + existing.slice(i);
  else
      return existing;
};

FlowDiagramHelper.obtainTriggerInstances = function(triggerInstancesJson) {
  var triggerInstances = [];
  for (var i = 0; i < triggerInstancesJson.length; i++) {
      var triggerInstance = triggerInstancesJson[i];
      var instanceInputs = [];
      var instanceOutputs = [];

      for (var inputI = 0; inputI < triggerInstance.inputs.length; inputI++) {
          var input = triggerInstance.inputs[inputI];
          instanceInputs.push({
              value: input.value,
              label: input.label,
              name: input.name
          });
      }

      for (var outputI = 0; outputI < triggerInstance.outputs.length; outputI++) {
          var output = triggerInstance.outputs[outputI];
          instanceOutputs.push({
              type: output.type,
              label: output.label,
              name: output.name
          });
      }

      triggerInstances.push({
          name: triggerInstance.name,
          triggerInstanceId: triggerInstance.id,
          triggerType: triggerInstance.type,
          inputs: instanceInputs,
          outputs: instanceOutputs
      });
  }

  return triggerInstances;
};

/**
* Generate node name for Flow logic
*/
FlowDiagramHelper.generateFlowLogicNodeName = function(instance) {
  var name = instance.name;

  if (instance.flowLogicDefinition && instance.flowLogicDefinition.name) {
      name = instance.flowLogicDefinition.name;

      if(instance.flowLogicDefinition.type === 'DOUNTIL') {
          name = FlowDiagramConstants.NODE_NAMES.DO_FOLLOWING;
      }
      else if (instance.data) {
          name = FlowDiagramHelper.generateNameWithCondition(name, instance.data);
      }
  }


  return name;
};


/**
* Generate node name with condition info for flow logics
*/
FlowDiagramHelper.generateNameWithCondition = function(name, conditionData) {
  var nameWithCondition = name;

  if(conditionData) {
      var conditionValue = conditionData.condition_name || conditionData.condition || conditionData.items;
      nameWithCondition = name + (conditionValue ? ': ' + conditionValue : '');
  }


  return nameWithCondition;
};

/**
* Generate node name for action, subflow, flowlogic
*/
FlowDiagramHelper.generateNodeName = function(instance) {

  switch (_getType(instance)) {
      case 'action':
          return instance.name ? instance.name : (instance.actionType.fName || instance.actionType.name);

      case 'subflow':
          return instance.name ? instance.name : instance.subFlow.name;

      case 'flowlogic':
          return FlowDiagramHelper.generateFlowLogicNodeName(instance);

      default:
          return instance.name || '';
  }

  function _getType(instance) {
      if (instance.actionType) return 'action';
      if (instance.subFlow) return 'subflow';
      if (instance.flowLogicDefinition) return 'flowlogic';

      return '';
  }
};

var GOBACKTO_FROM_LABEL_PREFIX = "Back from ";
var GOBACKTO_LABEL_DELIM = ", ";
FlowDiagramHelper.addAndSortLabelOrders = function(label, newOrder) {
  if (!label) {
      return "";
  }
  var ordersStr = label.split(GOBACKTO_FROM_LABEL_PREFIX)[1];
  if (!ordersStr) {
      return label;
  }
  var orderArr = ordersStr.split(GOBACKTO_LABEL_DELIM);
  if (newOrder) {
      orderArr.push(newOrder);
  }
  return orderArr.sort(function(a, b) {
      var intA = JSON.parse(a);
      var intB = JSON.parse(b);
      if (intA > intB) return 1;
      if (intA < intB) return -1;
      return 0;
  }).join(GOBACKTO_LABEL_DELIM);
};

FlowDiagramHelper.getGoBackToLabel = function(key, order, currentLabel) {
  if (key && typeof order === "number") {
      if (currentLabel) {
          var orders = FlowDiagramHelper.addAndSortLabelOrders(currentLabel, order);
          return GOBACKTO_FROM_LABEL_PREFIX + orders;
      }
      return GOBACKTO_FROM_LABEL_PREFIX + order;
  }
  return "";
};

Sys ID

b91bca65ff0130104ef14ee9453bf1d4

Offical Documentation

Official Docs: