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