it('should fetch task listener properties for an user task', inject(function(propertiesPanel, selection, elementRegistry) {
var taskShape = elementRegistry.get('UserTask_1');
selection.select(taskShape);
var bo = getBusinessObject(taskShape),
eventTypes = domQuery.all('select[name=eventType]', propertiesPanel._container),
listenerTypes = domQuery.all('select[name=listenerType]', propertiesPanel._container),
listenerValues = domQuery.all('input[name=listenerValue]', propertiesPanel._container);
expect(bo.extensionElements.values).to.have.length.of(2);
expect(eventTypes).to.have.length.of(2);
expect(listenerTypes).to.have.length.of(2);
expect(listenerValues).to.have.length.of(2);
var extensionElementsValues = bo.extensionElements.values;
// execution listener
expect(eventTypes[0].value).to.equal('end');
expect(listenerTypes[0].value).to.equal('expression');
expect(listenerValues[0].value).to.equal('executionListenerExpr');
expect(is(extensionElementsValues[0], 'camunda:ExecutionListener')).to.be.true;
expect(extensionElementsValues[0].get('event')).to.equal(eventTypes[0].value);
expect(extensionElementsValues[0].get('expression')).to.equal(listenerValues[0].value);
// task listener
expect(eventTypes[1].value).to.equal('assignment');
expect(listenerTypes[1].value).to.equal('expression');
expect(listenerValues[1].value).to.equal('abc');
expect(is(extensionElementsValues[1], 'camunda:TaskListener')).to.be.true;
expect(extensionElementsValues[1].get('event')).to.equal(eventTypes[1].value);
expect(extensionElementsValues[1].get('expression')).to.equal(listenerValues[1].value);
}));
it('should add constraint on bo without existing extension elements', inject(function(elementRegistry, selection) {
var shape = elementRegistry.get('UserTask_1');
// when
// select user task with form key
selection.select(shape);
// add form field
var createFormFieldButton = domQuery('[data-entry="form-fields"] [data-action="createElement"]', container);
TestHelper.triggerEvent(createFormFieldButton, 'click');
// add constraint
var addConstraintButton = domQuery('[data-entry="constraints-list"] [data-action="addElement"]', container);
TestHelper.triggerEvent(addConstraintButton, 'click');
var formData = getExtensionElements(getBusinessObject(shape), 'camunda:FormData');
var formField = formData[0].fields[0];
// then
expect(is(formField.validation, 'camunda:Validation')).to.be.true;
var constraints = formField.validation.constraints;
expect(constraints).to.have.length(1);
expect(is(constraints[0], 'camunda:Constraint'));
expect(constraints[0].name).to.be.undefined;
expect(constraints[0].config).to.be.undefined;
}));
module.exports = function(group, element, bpmnFactory) {
var businessObject = getBusinessObject(element);
if (is(element, 'camunda:JobPriorized') ||
is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
group.entries = group.entries.concat(jobPriority(element, bpmnFactory, {
getBusinessObject: function(element) {
var bo = getBusinessObject(element);
if (!is(bo, 'bpmn:Participant')) {
return bo;
}
return bo.get('processRef');
}
}));
}
if (is(element, 'camunda:AsyncCapable')) {
group.entries = group.entries.concat(jobRetryTimeCycle(element, bpmnFactory, {
getBusinessObject: getBusinessObject
}));
}
};
module.exports = function(group, element, translate) {
var bo = getBusinessObject(element);
if (!bo) {
return;
}
if (is(element, 'bpmn:Process') || (is(element, 'bpmn:Participant') && bo.get('processRef'))) {
var executableEntry = entryFactory.checkbox({
id: 'process-is-executable',
label: translate('Executable'),
modelProperty: 'isExecutable'
});
// in participants we have to change the default behavior of set and get
if (is(element, 'bpmn:Participant')) {
executableEntry.get = function(element) {
return participantHelper.getProcessBusinessObject(element, 'isExecutable');
};
executableEntry.set = function(element, values) {
return participantHelper.modifyProcessBusinessObject(element, 'isExecutable', values);
};
}
group.entries.push(executableEntry);
}
};
/**
* Can shape be created on target container?
*/
function canCreate(shape, target) {
// only judge about custom elements
if (!isCustom(shape)) {
return;
}
// allow creation on processes
return is(target, 'bpmn:Process') || is(target, 'bpmn:Participant') || is(target, 'bpmn:Collaboration');
}
forEach(errorEvents, function(event) {
if(is(element, event)) {
var showErrorCodeVariable = is(element, 'bpmn:StartEvent') || is (element, 'bpmn:BoundaryEvent');
var errorEventDefinition = eventDefinitionHelper.getErrorEventDefinition(element);
if(errorEventDefinition) {
error(group, element, bpmnFactory, errorEventDefinition, showErrorCodeVariable);
}
}
});
var getInputOutputParameterLabel = function(param) {
if (is(param, 'camunda:InputParameter')) {
return 'Input Parameter';
}
if (is(param, 'camunda:OutputParameter')) {
return 'Output Parameter';
}
return '';
};
forEach(escalationEvents, function(event) {
if(is(element, event)) {
var showEscalationCodeVariable = is(element, 'bpmn:StartEvent') || is(element, 'bpmn:BoundaryEvent');
// get business object
var escalationEventDefinition = eventDefinitionHelper.getEscalationEventDefinition(element);
if(escalationEventDefinition) {
escalation(group, element, bpmnFactory, escalationEventDefinition, showEscalationCodeVariable);
}
}
});
var isExternalTaskPriorityEnabled = function(element) {
var businessObject = getBusinessObject(element);
// show only if element is a process, a participant ...
if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
return true;
}
var externalBo = ImplementationTypeHelper.getServiceTaskLikeBusinessObject(element),
isExternalTask = ImplementationTypeHelper.getImplementationType(externalBo) === 'external';
// ... or an external task with selected external implementation type
return !!ImplementationTypeHelper.isExternalCapable(externalBo) && isExternalTask;
};
it('should not fetch task listener properties for a sequence flow', inject(function(propertiesPanel, selection, elementRegistry) {
var taskShape = elementRegistry.get('SequenceFlow_1');
selection.select(taskShape);
var bo = getBusinessObject(taskShape),
taskListenersEntry = domQuery.all('[data-entry=taskListeners]', propertiesPanel._container);
expect(bo.extensionElements.values).to.have.length.of(1);
expect(taskListenersEntry).to.have.length(0);
expect(is(bo.extensionElements.values[0], 'camunda:ExecutionListener')).to.be.true;
expect(is(bo.extensionElements.values[0], 'camunda:TaskListener')).to.be.false;
}));
get: function (element, node) {
var mapping = getSelected(element, node);
var value = '';
if (is(mapping, CAMUNDA_IN_EXTENSION_ELEMENT)) {
value = 'In Mapping';
}
else if (is(mapping, CAMUNDA_OUT_EXTENSION_ELEMENT)) {
value = 'Out Mapping';
}
return {
label: value
};
},
this.addRule('shape.replace', HIGH_PRIORITY, function(element) {
var businessObject = element.element.businessObject;
if (is(businessObject, 'bpmn:ExclusiveGateway')) {
//return false; //here you could completely disable morph for gateways
return true;
}
});
forEach(linkEvents, function(event) {
if(is(element, event)) {
var linkEventDefinition = getLinkEventDefinition(element);
if(linkEventDefinition) {
var entry = entryFactory.textField({
id: 'link-event',
description: '',
label: 'Link Name',
modelProperty: 'link-name'
});
entry.get = function () {
return { 'link-name': linkEventDefinition.get('name')};
};
entry.set = function (element, values) {
var newProperties = {
name: values['link-name']
};
return cmdHelper.updateBusinessObject(element, linkEventDefinition, newProperties);
};
group.entries.push(entry);
}
}
});
forEach(rootElements, function(rootElement) {
if (is(rootElement, referenceType)) {
if (rootElement.id === properties[referenceProperty]) {
properties[referenceProperty] = rootElement;
}
}
});
module.exports = function(group, element, translate) {
var bo = getBusinessObject(element);
if (!bo) {
return;
}
if (is(element, 'camunda:Initiator') && !is(element.parent, 'bpmn:SubProcess')) {
group.entries.push(entryFactory.textField({
id: 'initiator',
label: translate('Initiator'),
modelProperty: 'initiator'
}));
}
};
it('should retain other extension elements when switching to formKey', inject(function(propertiesPanel, elementRegistry, selection) {
shape = elementRegistry.get('UserTask_2');
selection.select(shape);
var selectBox = domQuery('select[name=formType]', propertiesPanel._container);
selectBox.options[0].selected = 'selected';
// when
TestHelper.triggerEvent(selectBox, 'change');
var taskBo = getBusinessObject(shape);
expect(taskBo.extensionElements).to.exist;
expect(is(taskBo.extensionElements.values[0], 'camunda:TaskListener')).to.be.true;
expect(taskBo.formKey).to.be.undefined;
taskBo.$model.toXML(taskBo, { format:true }, function(err, xml) {
expect(xml).not.to.contain('camunda:formKey');
expect(xml).not.to.contain('camunda:formData');
expect(xml).to.contain('camunda:taskListener');
});
}));
module.exports = function(group, element, bpmnFactory, translate) {
var bo;
if (is(element, 'bpmn:ScriptTask')) {
bo = getBusinessObject(element);
}
if (!bo) {
return;
}
var script = scriptImplementation('scriptFormat', 'script', false, translate);
group.entries.push({
id: 'script-implementation',
label: translate('Script'),
html: script.template,
get: function(element) {
return script.get(element, bo);
},
set: function(element, values, containerElement) {
var properties = script.set(element, values, containerElement);
return cmdHelper.updateProperties(element, properties);
},
validate: function(element, values) {
return script.validate(element, values);
},
script : script,
cssClasses: ['bpp-textfield']
});
group.entries.push(entryFactory.textField({
id : 'scriptResultVariable',
label : translate('Result Variable'),
modelProperty : 'scriptResultVariable',
get: function(element, propertyName) {
var boResultVariable = bo.get('camunda:resultVariable');
return { scriptResultVariable : boResultVariable };
},
set: function(element, values, containerElement) {
return cmdHelper.updateProperties(element, {
'camunda:resultVariable': values.scriptResultVariable.length
? values.scriptResultVariable
: undefined
});
}
}));
};
forEach(extensionElements.values, function(value) {
if (is(value, type) &&
(typeof value.source !== 'undefined' ||
typeof value.sourceExpression !== 'undefined' ||
value.variables === 'all')) {
mappings.push(value);
}
});
module.exports = function(group, element, bpmnFactory) {
var bo;
if (is(element, 'bpmn:ScriptTask')) {
bo = getBusinessObject(element);
}
if (!bo) {
return;
}
group.entries.push({
'id': 'script-implementation',
'description': 'Implementation for a Script.',
label: 'Script',
'html': script.template,
get: function (element) {
return script.get(element, bo);
},
set: function(element, values, containerElement) {
var properties = script.set(element, values, containerElement);
return cmdHelper.updateProperties(element, properties);
},
validate: function(element, values) {
return script.validate(element, values);
},
script : script,
cssClasses: ['pp-textfield']
});
group.entries.push(entryFactory.textField({
id : 'scriptResultVariable',
description : 'Result Variable of a Service Task Script',
label : 'Result Variable',
modelProperty : 'scriptResultVariable',
get: function(element, propertyName) {
var boResultVariable = bo.get('camunda:resultVariable');
return { scriptResultVariable : boResultVariable };
},
set: function(element, values, containerElement) {
return cmdHelper.updateProperties(element, {
'camunda:resultVariable': values.scriptResultVariable
});
}
}));
};
it('should not fetch task listener properties for a sequence flow', inject(function(propertiesPanel, selection, elementRegistry) {
var taskShape = elementRegistry.get('SequenceFlow_1');
selection.select(taskShape);
var bo = getBusinessObject(taskShape),
executionListeners = getSelect(container, 'selectedExtensionElement', 'executionListeners'),
taskListeners = getSelect(container, 'selectedExtensionElement', 'taskListeners');
expect(is(bo.extensionElements.values[0], 'camunda:ExecutionListener')).to.be.true;
expect(is(bo.extensionElements.values[0], 'camunda:TaskListener')).to.be.false;
expect(bo.extensionElements.values).to.have.length.of(1);
expect(executionListeners).to.be.defined;
expect(taskListeners).to.be.null;
}));
getBusinessObject: function(element) {
var bo = getBusinessObject(element);
if (!is(bo, 'bpmn:Participant')) {
return bo;
}
return bo.get('processRef');
}
forEach(events, function(event) {
if(is(element, event)) {
var messageEventDefinition = eventDefinitionHelper.getMessageEventDefinition(element),
signalEventDefinition = eventDefinitionHelper.getSignalEventDefinition(element);
if(messageEventDefinition) {
message(group, element, bpmnFactory, messageEventDefinition);
}
if(signalEventDefinition) {
if(!is(element,"bpmn:EndEvent")){
signal(group, element, bpmnFactory, signalEventDefinition);
}
}
}
});
module.exports = function(group, element, bpmnFactory) {
var bo = getServiceTaskLikeBusinessObject(element);
if(!bo) {
return;
}
if (is(bo, 'camunda:TaskPriorized') || (is(bo, 'bpmn:Participant')) && bo.get('processRef')) {
group.entries = group.entries.concat(externalTaskPriority(element, bpmnFactory, {
getBusinessObject: function(element) {
if (!is(bo, 'bpmn:Participant')) {
return bo;
}
return bo.get('processRef');
}
}));
}
};
var isJobConfigEnabled = function(element) {
var businessObject = getBusinessObject(element);
if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
return true;
}
// async behavior
var bo = getBusinessObject(element);
if (asyncCapableHelper.isAsyncBefore(bo) || asyncCapableHelper.isAsyncAfter(bo)) {
return true;
}
// timer definition
if (is(element, 'bpmn:Event')) {
return !!eventDefinitionHelper.getTimerEventDefinition(element);
}
return false;
};
forEach(compensationEvents, function(event) {
if(is(element, event)) {
// get business object
var compensateEventDefinition = eventDefinitionHelper.getCompensateEventDefinition(element);
if(compensateEventDefinition) {
compensation(group, element, bpmnFactory, compensateEventDefinition, elementRegistry);
}
}
});
forEach(timerEvents, function(event) {
if(is(element, event)) {
// get business object
var timerEventDefinition = eventDefinitionHelper.getTimerEventDefinition(element);
if(timerEventDefinition) {
timer(group, element, bpmnFactory, timerEventDefinition);
}
}
});
module.exports = function(group, element, bpmnFactory, translate) {
var businessObject = getBusinessObject(element);
if (is(element, 'camunda:Process') ||
is(element, 'bpmn:Participant') && businessObject.get('processRef')) {
group.entries = group.entries.concat(candidateStarter(element, bpmnFactory, {
getBusinessObject: function(element) {
var bo = getBusinessObject(element);
if (!is(bo, 'bpmn:Participant')) {
return bo;
}
return bo.get('processRef');
}
}, translate));
}
};
it('should execute', function() {
// when selecting first form field
// then
var constraints = getConstraints(shape, 0),
lastConstraint = constraints[constraints.length-1];
expect(constraints).to.have.length(3);
expect(is(lastConstraint, 'camunda:Constraint')).to.be.true;
expect(lastConstraint.name).to.be.undefined;
expect(lastConstraint.config).to.be.undefined;
});
module.exports = function(group, element) {
if (is(element, 'camunda:Assignable')) {
// Assignee
group.entries.push(entryFactory.textField({
id : 'assignee',
description : 'Assignee of the User Task',
label : 'Assignee',
modelProperty : 'assignee'
}));
// Candidate Users
group.entries.push(entryFactory.textField({
id : 'candidateUsers',
description : 'A list of candidates for this User Task',
label : 'Candidate Users',
modelProperty : 'candidateUsers'
}));
// Candidate Groups
group.entries.push(entryFactory.textField({
id : 'candidateGroups',
description : 'A list of candidate groups for this User Task',
label : 'Candidate Groups',
modelProperty : 'candidateGroups'
}));
// Due Date
group.entries.push(entryFactory.textField({
id : 'dueDate',
description : 'The due date as an EL expression (e.g. ${someDate} or an ISO date (e.g. 2015-06-26T09:54:00)',
label : 'Due Date',
modelProperty : 'dueDate'
}));
// FollowUp Date
group.entries.push(entryFactory.textField({
id : 'followUpDate',
description : 'The follow up date as an EL expression (e.g. ${someDate} or an ' +
'ISO date (e.g. 2015-06-26T09:54:00)',
label : 'Follow Up Date',
modelProperty : 'followUpDate'
}));
// priority
group.entries.push(entryFactory.textField({
id : 'priority',
description : 'Priority of this User Task',
label : 'Priority',
modelProperty : 'priority'
}));
}
};
module.exports = function(group, element) {
var bo = getBusinessObject(element);
if (!bo) {
return;
}
if (is(element, 'bpmn:Process') || is(element, 'bpmn:Participant') && bo.get('processRef')) {
var versionTagEntry = entryFactory.textField({
id: 'versionTag',
description: 'version tag of the process',
label: 'Version Tag',
modelProperty: 'versionTag'
});
// in participants we have to change the default behavior of set and get
if (is(element, 'bpmn:Participant')) {
versionTagEntry.get = function(element) {
var processBo = bo.get('processRef');
return {
versionTag: processBo.get('camunda:versionTag')
};
};
versionTagEntry.set = function(element, values) {
var processBo = bo.get('processRef');
return cmdHelper.updateBusinessObject(element, processBo, {
'camunda:versionTag': values.versionTag || undefined
});
};
}
group.entries.push(versionTagEntry);
}
};