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

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