gerrit.onap Code Review - sdc/sdc-workflow-designer.git/blob

   1 'use strict';
   2
   3 var is = require('bpmn-js/lib/util/ModelUtil').is;
   4
   5 var elementHelper = require('bpmn-js-properties-panel/lib/helper/ElementHelper'),
   6     inputOutputHelper = require('./InputOutputHelper'),
   7     cmdHelper = require('bpmn-js-properties-panel/lib/helper/CmdHelper'),
   8     utils = require('bpmn-js-properties-panel/lib/Utils');
   9
  10 var entryFactory = require('bpmn-js-properties-panel/lib/factory/EntryFactory'),
  11     script = require('bpmn-js-properties-panel/lib/provider/camunda/parts/implementation/Script')(
  12         'scriptFormat',
  13         'value',
  14         true
  15     );
  16
  17 function createElement(type, parent, factory, properties) {
  18     return elementHelper.createElement(type, properties, parent, factory);
  19 }
  20
  21 function isScript(elem) {
  22     return is(elem, 'camunda:Script');
  23 }
  24
  25 function isList(elem) {
  26     return is(elem, 'camunda:List');
  27 }
  28
  29 function isMap(elem) {
  30     return is(elem, 'camunda:Map');
  31 }
  32
  33 function ensureInputOutputSupported(element, insideConnector) {
  34     return inputOutputHelper.isInputOutputSupported(element, insideConnector);
  35 }
  36
  37 module.exports = function(element, bpmnFactory, options, translate) {
  38     var typeInfo = {
  39         'camunda:Map': {
  40             value: 'map',
  41             label: translate('Map')
  42         },
  43         'camunda:List': {
  44             value: 'list',
  45             label: translate('List')
  46         },
  47         'camunda:Script': {
  48             value: 'script',
  49             label: translate('Script')
  50         }
  51     };
  52
  53     options = options || {};
  54
  55     var insideConnector = !!options.insideConnector,
  56         idPrefix = options.idPrefix || '';
  57
  58     var getSelected = options.getSelectedParameter;
  59
  60     if (!ensureInputOutputSupported(element, insideConnector)) {
  61         return [];
  62     }
  63
  64     var entries = [];
  65
  66     var isSelected = function(element, node) {
  67         return getSelected(element, node);
  68     };
  69
  70     // parameter name ////////////////////////////////////////////////////////
  71
  72     entries.push(
  73         entryFactory.validationAwareTextField({
  74             id: idPrefix + 'parameterName',
  75             label: 'Name',
  76             modelProperty: 'name',
  77
  78             getProperty: function(element, node) {
  79                 return (getSelected(element, node) || {}).name;
  80             },
  81
  82             setProperty: function(element, values, node) {
  83                 var param = getSelected(element, node);
  84                 return cmdHelper.updateBusinessObject(element, param, values);
  85             },
  86
  87             validate: function(element, values, node) {
  88                 var bo = getSelected(element, node);
  89
  90                 var validation = {};
  91                 if (bo) {
  92                     var nameValue = values.name;
  93
  94                     if (nameValue) {
  95                         if (utils.containsSpace(nameValue)) {
  96                             validation.name = 'Name must not contain spaces';
  97                         }
  98                     } else {
  99                         validation.name = 'Parameter must have a name';
 100                     }
 101                 }
 102
 103                 return validation;
 104             },
 105
 106             hidden: function(element, node) {
 107                 return !isSelected(element, node);
 108             },
 109             disabled: function(element) {
 110                 return !inputOutputHelper.isCreateDeleteSupported(element);
 111             }
 112         })
 113     );
 114
 115     // parameter type //////////////////////////////////////////////////////
 116
 117     var selectOptions = [
 118         { value: 'text', name: 'Text' },
 119         { value: 'script', name: 'Script' },
 120         { value: 'list', name: 'List' },
 121         { value: 'map', name: 'Map' }
 122     ];
 123
 124     entries.push(
 125         entryFactory.selectBox({
 126             id: idPrefix + 'parameterType',
 127             label: 'Type',
 128             selectOptions: selectOptions,
 129             modelProperty: 'parameterType',
 130
 131             get: function(element, node) {
 132                 var bo = getSelected(element, node);
 133
 134                 var parameterType = 'text';
 135
 136                 if (typeof bo !== 'undefined') {
 137                     var definition = bo.get('definition');
 138                     if (typeof definition !== 'undefined') {
 139                         var type = definition.$type;
 140                         parameterType = typeInfo[type].value;
 141                     }
 142                 }
 143
 144                 return {
 145                     parameterType: parameterType
 146                 };
 147             },
 148
 149             set: function(element, values, node) {
 150                 var bo = getSelected(element, node);
 151
 152                 var properties = {
 153                     value: undefined,
 154                     definition: undefined
 155                 };
 156
 157                 var createParameterTypeElem = function(type) {
 158                     return createElement(type, bo, bpmnFactory);
 159                 };
 160
 161                 var parameterType = values.parameterType;
 162
 163                 if (parameterType === 'script') {
 164                     properties.definition = createParameterTypeElem(
 165                         'camunda:Script'
 166                     );
 167                 } else if (parameterType === 'list') {
 168                     properties.definition = createParameterTypeElem(
 169                         'camunda:List'
 170                     );
 171                 } else if (parameterType === 'map') {
 172                     properties.definition = createParameterTypeElem(
 173                         'camunda:Map'
 174                     );
 175                 }
 176
 177                 return cmdHelper.updateBusinessObject(element, bo, properties);
 178             },
 179
 180             show: function(element, node) {
 181                 return isSelected(element, node);
 182             },
 183             disabled: function(element) {
 184                 return !inputOutputHelper.isCreateDeleteSupported(element);
 185             }
 186         })
 187     );
 188
 189     // parameter value (type = text) ///////////////////////////////////////////////////////
 190
 191     entries.push(
 192         entryFactory.textBox({
 193             id: idPrefix + 'parameterType-text',
 194             label: 'Value',
 195             modelProperty: 'value',
 196             get: function(element, node) {
 197                 return {
 198                     value: (getSelected(element, node) || {}).value
 199                 };
 200             },
 201
 202             set: function(element, values, node) {
 203                 var param = getSelected(element, node);
 204                 values.value = values.value || undefined;
 205                 return cmdHelper.updateBusinessObject(element, param, values);
 206             },
 207
 208             show: function(element, node) {
 209                 var bo = getSelected(element, node);
 210                 return bo && !bo.definition;
 211             }
 212         })
 213     );
 214
 215     // parameter value (type = script) ///////////////////////////////////////////////////////
 216
 217     entries.push({
 218         id: idPrefix + 'parameterType-script',
 219         html: '<div data-show="isScript">' + script.template + '</div>',
 220         get: function(element, node) {
 221             var bo = getSelected(element, node);
 222             return bo && isScript(bo.definition)
 223                 ? script.get(element, bo.definition)
 224                 : {};
 225         },
 226
 227         set: function(element, values, node) {
 228             var bo = getSelected(element, node);
 229             var update = script.set(element, values);
 230             return cmdHelper.updateBusinessObject(
 231                 element,
 232                 bo.definition,
 233                 update
 234             );
 235         },
 236
 237         validate: function(element, values, node) {
 238             var bo = getSelected(element, node);
 239             return bo && isScript(bo.definition)
 240                 ? script.validate(element, bo.definition)
 241                 : {};
 242         },
 243
 244         isScript: function(element, node) {
 245             var bo = getSelected(element, node);
 246             return bo && isScript(bo.definition);
 247         },
 248
 249         script: script
 250     });
 251
 252     // parameter value (type = list) ///////////////////////////////////////////////////////
 253
 254     entries.push(
 255         entryFactory.table({
 256             id: idPrefix + 'parameterType-list',
 257             modelProperties: ['value'],
 258             labels: ['Value'],
 259
 260             getElements: function(element, node) {
 261                 var bo = getSelected(element, node);
 262
 263                 if (bo && isList(bo.definition)) {
 264                     return bo.definition.items;
 265                 }
 266
 267                 return [];
 268             },
 269
 270             updateElement: function(element, values, node, idx) {
 271                 var bo = getSelected(element, node);
 272                 var item = bo.definition.items[idx];
 273                 return cmdHelper.updateBusinessObject(element, item, values);
 274             },
 275
 276             addElement: function(element, node) {
 277                 var bo = getSelected(element, node);
 278                 var newValue = createElement(
 279                     'camunda:Value',
 280                     bo.definition,
 281                     bpmnFactory,
 282                     { value: undefined }
 283                 );
 284                 return cmdHelper.addElementsTolist(
 285                     element,
 286                     bo.definition,
 287                     'items',
 288                     [newValue]
 289                 );
 290             },
 291
 292             removeElement: function(element, node, idx) {
 293                 var bo = getSelected(element, node);
 294                 return cmdHelper.removeElementsFromList(
 295                     element,
 296                     bo.definition,
 297                     'items',
 298                     null,
 299                     [bo.definition.items[idx]]
 300                 );
 301             },
 302
 303             editable: function(element, node, prop, idx) {
 304                 var bo = getSelected(element, node);
 305                 var item = bo.definition.items[idx];
 306                 return !isMap(item) && !isList(item) && !isScript(item);
 307             },
 308
 309             setControlValue: function(element, node, input, prop, value, idx) {
 310                 var bo = getSelected(element, node);
 311                 var item = bo.definition.items[idx];
 312
 313                 if (!isMap(item) && !isList(item) && !isScript(item)) {
 314                     input.value = value;
 315                 } else {
 316                     input.value = typeInfo[item.$type].label;
 317                 }
 318             },
 319
 320             show: function(element, node) {
 321                 var bo = getSelected(element, node);
 322                 return bo && bo.definition && isList(bo.definition);
 323             }
 324         })
 325     );
 326
 327     // parameter value (type = map) ///////////////////////////////////////////////////////
 328
 329     entries.push(
 330         entryFactory.table({
 331             id: idPrefix + 'parameterType-map',
 332             modelProperties: ['key', 'value'],
 333             labels: ['Key', 'Value'],
 334             addLabel: 'Add Entry',
 335
 336             getElements: function(element, node) {
 337                 var bo = getSelected(element, node);
 338
 339                 if (bo && isMap(bo.definition)) {
 340                     return bo.definition.entries;
 341                 }
 342
 343                 return [];
 344             },
 345
 346             updateElement: function(element, values, node, idx) {
 347                 var bo = getSelected(element, node);
 348                 var entry = bo.definition.entries[idx];
 349
 350                 if (
 351                     isMap(entry.definition) ||
 352                     isList(entry.definition) ||
 353                     isScript(entry.definition)
 354                 ) {
 355                     values = {
 356                         key: values.key
 357                     };
 358                 }
 359
 360                 return cmdHelper.updateBusinessObject(element, entry, values);
 361             },
 362
 363             addElement: function(element, node) {
 364                 var bo = getSelected(element, node);
 365                 var newEntry = createElement(
 366                     'camunda:Entry',
 367                     bo.definition,
 368                     bpmnFactory,
 369                     { key: undefined, value: undefined }
 370                 );
 371                 return cmdHelper.addElementsTolist(
 372                     element,
 373                     bo.definition,
 374                     'entries',
 375                     [newEntry]
 376                 );
 377             },
 378
 379             removeElement: function(element, node, idx) {
 380                 var bo = getSelected(element, node);
 381                 return cmdHelper.removeElementsFromList(
 382                     element,
 383                     bo.definition,
 384                     'entries',
 385                     null,
 386                     [bo.definition.entries[idx]]
 387                 );
 388             },
 389
 390             editable: function(element, node, prop, idx) {
 391                 var bo = getSelected(element, node);
 392                 var entry = bo.definition.entries[idx];
 393                 return (
 394                     prop === 'key' ||
 395                     (!isMap(entry.definition) &&
 396                         !isList(entry.definition) &&
 397                         !isScript(entry.definition))
 398                 );
 399             },
 400
 401             setControlValue: function(element, node, input, prop, value, idx) {
 402                 var bo = getSelected(element, node);
 403                 var entry = bo.definition.entries[idx];
 404
 405                 if (
 406                     prop === 'key' ||
 407                     (!isMap(entry.definition) &&
 408                         !isList(entry.definition) &&
 409                         !isScript(entry.definition))
 410                 ) {
 411                     input.value = value;
 412                 } else {
 413                     input.value = typeInfo[entry.definition.$type].label;
 414                 }
 415             },
 416
 417             show: function(element, node) {
 418                 var bo = getSelected(element, node);
 419                 return bo && bo.definition && isMap(bo.definition);
 420             }
 421         })
 422     );
 423
 424     return entries;
 425 };