//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @BpmnModelResource public void shouldFindReferenceWithNamespace()
public virtual void shouldFindReferenceWithNamespace()
{
MessageEventDefinition messageEventDefinition = bpmnModelInstance.getModelElementById("message-event-definition");
Message message = bpmnModelInstance.getModelElementById("message-id");
assertThat(messageEventDefinition.Message).NotNull;
assertThat(messageEventDefinition.Message).isEqualTo(message);
message.Id = "changed-message";
assertThat(messageEventDefinition.Message).NotNull;
assertThat(messageEventDefinition.Message).isEqualTo(message);
message.setAttributeValue("id", "again-changed-message", true);
assertThat(messageEventDefinition.Message).NotNull;
assertThat(messageEventDefinition.Message).isEqualTo(message);
StartEvent startEvent = bpmnModelInstance.getModelElementById("start-event");
ICollection <EventDefinition> eventDefinitionRefs = startEvent.EventDefinitionRefs;
assertThat(eventDefinitionRefs).NotEmpty;
assertThat(eventDefinitionRefs).contains(messageEventDefinition);
messageEventDefinition.Id = "changed-message-event";
assertThat(eventDefinitionRefs).NotEmpty;
assertThat(eventDefinitionRefs).contains(messageEventDefinition);
messageEventDefinition.setAttributeValue("id", "again-changed-message-event", true);
assertThat(eventDefinitionRefs).NotEmpty;
assertThat(eventDefinitionRefs).contains(messageEventDefinition);
message.removeAttribute("id");
assertThat(messageEventDefinition.Message).Null;
messageEventDefinition.removeAttribute("id");
assertThat(eventDefinitionRefs).doesNotContain(messageEventDefinition);
assertThat(eventDefinitionRefs).Empty;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void createModel()
public virtual void createModel()
{
testBpmnModelInstance = Bpmn.createEmptyModel();
Definitions definitions = testBpmnModelInstance.newInstance(typeof(Definitions));
testBpmnModelInstance.Definitions = definitions;
message = testBpmnModelInstance.newInstance(typeof(Message));
message.Id = "message-id";
definitions.RootElements.Add(message);
Process process = testBpmnModelInstance.newInstance(typeof(Process));
process.Id = "process-id";
definitions.RootElements.Add(process);
startEvent = testBpmnModelInstance.newInstance(typeof(StartEvent));
startEvent.Id = "start-event-id";
process.FlowElements.Add(startEvent);
messageEventDefinition = testBpmnModelInstance.newInstance(typeof(MessageEventDefinition));
messageEventDefinition.Id = "msg-def-id";
messageEventDefinition.Message = message;
startEvent.EventDefinitions.Add(messageEventDefinition);
startEvent.EventDefinitionRefs.Add(messageEventDefinition);
}
public virtual void testRetryOnServiceTaskLikeMessageThrowEvent()
{
// given
BpmnModelInstance bpmnModelInstance = Bpmn.createExecutableProcess("process").startEvent().intermediateThrowEvent().camundaAsyncBefore().camundaFailedJobRetryTimeCycle("R10/PT5S").messageEventDefinition("messageDefinition").message("message").messageEventDefinitionDone().endEvent().done();
MessageEventDefinition messageDefinition = bpmnModelInstance.getModelElementById("messageDefinition");
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
messageDefinition.CamundaClass = typeof(FailingDelegate).FullName;
deployment(bpmnModelInstance);
runtimeService.startProcessInstanceByKey("process");
Job job = managementService.createJobQuery().singleResult();
// when job fails
try
{
managementService.executeJob(job.Id);
}
catch (Exception)
{
// ignore
}
// then
job = managementService.createJobQuery().singleResult();
Assert.assertEquals(9, job.Retries);
}
protected internal virtual MessageEventDefinition createMessageEventDefinition(string messageName)
{
Message message = findMessageForName(messageName);
MessageEventDefinition messageEventDefinition = createInstance(typeof(MessageEventDefinition));
messageEventDefinition.Message = message;
return(messageEventDefinition);
}
/// <summary>
/// Sets an event definition for the given message name. If already a message
/// with this name exists it will be used, otherwise a new message is created.
/// </summary>
/// <param name="messageName"> the name of the message </param>
/// <returns> the builder object </returns>
public virtual B message(string messageName)
{
MessageEventDefinition messageEventDefinition = createMessageEventDefinition(messageName);
element.EventDefinitions.add(messageEventDefinition);
return(myself);
}
public override BaseElement Clone()
{
MessageEventDefinition clone = new MessageEventDefinition
{
Values = this
};
return(clone);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void getEventDefinition()
public virtual void getEventDefinition()
{
MessageEventDefinition eventDefinition = eventDefinitionQuery.filterByType(typeof(MessageEventDefinition)).singleResult();
assertThat(eventDefinition).NotNull;
assertThat(eventDefinition.Message.Id).isEqualTo("message");
assertThat(eventDefinition.Operation).Null;
assertThat(eventDefinition.CamundaTaskPriority).isEqualTo("5");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAddParentChildElementInCorrectOrder()
public virtual void shouldAddParentChildElementInCorrectOrder()
{
// create empty model
BpmnModelInstance bpmnModelInstance = Bpmn.createEmptyModel();
// add definitions to model
Definitions definitions = bpmnModelInstance.newInstance(typeof(Definitions));
definitions.TargetNamespace = "Examples";
bpmnModelInstance.Definitions = definitions;
// add process
Process process = bpmnModelInstance.newInstance(typeof(Process));
process.Id = "messageEventDefinition";
definitions.RootElements.Add(process);
// add start event
StartEvent startEvent = bpmnModelInstance.newInstance(typeof(StartEvent));
startEvent.Id = "theStart";
process.FlowElements.Add(startEvent);
// create and add message
Message message = bpmnModelInstance.newInstance(typeof(Message));
message.Id = "start-message-id";
definitions.RootElements.Add(message);
// add message event definition to start event
MessageEventDefinition startEventMessageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
startEventMessageEventDefinition.Message = message;
startEvent.EventDefinitions.Add(startEventMessageEventDefinition);
// add property after message event definition
Property property = bpmnModelInstance.newInstance(typeof(Property));
startEvent.Properties.Add(property);
// finally add an extensions element
ExtensionElements extensionElements = bpmnModelInstance.newInstance(typeof(ExtensionElements));
process.ExtensionElements = extensionElements;
// validate model
try
{
Bpmn.validateModel(bpmnModelInstance);
}
catch (ModelValidationException)
{
Assert.fail();
}
}
public override object Clone()
{
var result = new MessageEventDefinition
{
MessageRef = MessageRef,
OperationRef = OperationRef
};
FeedElt(result);
return(result);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testShouldReplaceMessageEventDefinitionRefIfMessageEventDefinitionIsReplaced()
public virtual void testShouldReplaceMessageEventDefinitionRefIfMessageEventDefinitionIsReplaced()
{
MessageEventDefinition otherMessageEventDefinition = testBpmnModelInstance.newInstance(typeof(MessageEventDefinition));
otherMessageEventDefinition.Id = "other-message-event-definition-id";
ICollection <EventDefinition> eventDefinitionRefs = startEvent.EventDefinitionRefs;
assertThat(eventDefinitionRefs).contains(messageEventDefinition);
messageEventDefinition.replaceWithElement(otherMessageEventDefinition);
assertThat(eventDefinitionRefs).doesNotContain(messageEventDefinition);
assertThat(eventDefinitionRefs).contains(otherMessageEventDefinition);
}
/// <summary>
/// Creates an empty message event definition with the given id
/// and returns a builder for the message event definition.
/// </summary>
/// <param name="id"> the id of the message event definition </param>
/// <returns> the message event definition builder object </returns>
public virtual MessageEventDefinitionBuilder messageEventDefinition(string id)
{
MessageEventDefinition messageEventDefinition = createEmptyMessageEventDefinition();
if (!string.ReferenceEquals(id, null))
{
messageEventDefinition.Id = id;
}
element.EventDefinitions.add(messageEventDefinition);
return(new MessageEventDefinitionBuilder(modelInstance, messageEventDefinition));
}
private void addMessageEventDefinition(CatchEvent catchEvent)
{
BpmnModelInstance modelInstance = (BpmnModelInstance)catchEvent.ModelInstance;
Message message = modelInstance.newInstance(typeof(Message));
message.Id = MESSAGE_ID;
message.Name = MESSAGE_NAME;
modelInstance.Definitions.addChildElement(message);
MessageEventDefinition messageEventDefinition = modelInstance.newInstance(typeof(MessageEventDefinition));
messageEventDefinition.Message = message;
catchEvent.EventDefinitions.add(messageEventDefinition);
}
public IntermediateThrowMessageEventActivityBehavior(MessageEventDefinition messageEventDefinition, Message message)
{
if (message != null)
{
messageEventName = message.Name;
}
else if (!string.IsNullOrWhiteSpace(messageEventDefinition.MessageRef))
{
messageEventName = messageEventDefinition.MessageRef;
}
else
{
messageExpression = messageEventDefinition.MessageExpression;
}
this.messageEventDefinition = messageEventDefinition;
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
if (!(parentElement is Event))
{
return;
}
MessageEventDefinition eventDefinition = new MessageEventDefinition();
BpmnXMLUtil.AddXMLLocation(eventDefinition, xtr);
eventDefinition.MessageRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_MESSAGE_REF);
eventDefinition.MessageExpression = xtr.GetAttributeValue(BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE, BpmnXMLConstants.ATTRIBUTE_MESSAGE_EXPRESSION);
if (!string.IsNullOrWhiteSpace(eventDefinition.MessageRef))
{
int indexOfP = eventDefinition.MessageRef.IndexOf(':');
if (indexOfP != -1)
{
string prefix = eventDefinition.MessageRef.Substring(0, indexOfP);
string resolvedNamespace = model.GetNamespace(prefix);
string messageRef = eventDefinition.MessageRef.Substring(indexOfP + 1);
if (resolvedNamespace is null)
{
// if it's an invalid prefix will consider this is not a namespace prefix so will be used as part of the stringReference
messageRef = prefix + ":" + messageRef;
}
else if (!resolvedNamespace.Equals(model.TargetNamespace, StringComparison.CurrentCultureIgnoreCase))
{
// if it's a valid namespace prefix but it's not the targetNamespace then we'll use it as a valid namespace
// (even out editor does not support defining namespaces it is still a valid xml file)
messageRef = resolvedNamespace + ":" + messageRef;
}
eventDefinition.MessageRef = messageRef;
}
else
{
eventDefinition.MessageRef = eventDefinition.MessageRef;
}
}
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_EVENT_MESSAGEDEFINITION, eventDefinition, xtr, model);
((Event)parentElement).EventDefinitions.Add(eventDefinition);
}
protected internal virtual void HandleMessageEventDefinition(BpmnModel bpmnModel, Process process, Event @event, EventDefinition eventDefinition, IList <ValidationError> errors)
{
MessageEventDefinition messageEventDefinition = (MessageEventDefinition)eventDefinition;
if (string.IsNullOrWhiteSpace(messageEventDefinition.MessageRef))
{
if (string.IsNullOrWhiteSpace(messageEventDefinition.MessageExpression))
{
// message ref should be filled in
AddError(errors, ProblemsConstants.MESSAGE_EVENT_MISSING_MESSAGE_REF, process, @event, ProcessValidatorResource.MESSAGE_EVENT_MISSING_MESSAGE_REF);
}
}
else if (!bpmnModel.ContainsMessageId(messageEventDefinition.MessageRef))
{
// message ref should exist
AddError(errors, ProblemsConstants.MESSAGE_EVENT_INVALID_MESSAGE_REF, process, @event, ProcessValidatorResource.MESSAGE_EVENT_INVALID_MESSAGE_REF);
}
}
public virtual IProcessInstance CreateAndStartProcessInstanceByMessage(IProcessDefinition processDefinition, string messageName, IDictionary <string, object> variables, IDictionary <string, object> transientVariables)
{
_ = Context.CommandContext;
// Do not start process a process instance if the process definition is suspended
if (ProcessDefinitionUtil.IsProcessDefinitionSuspended(processDefinition.Id))
{
throw new ActivitiException("Cannot start process instance. Process definition " + processDefinition.Name + " (id = " + processDefinition.Id + ") is suspended");
}
// Get model from cache
Process process = ProcessDefinitionUtil.GetProcess(processDefinition.Id);
if (process == null)
{
throw new ActivitiException("Cannot start process instance. Process model " + processDefinition.Name + " (id = " + processDefinition.Id + ") could not be found");
}
FlowElement initialFlowElement = null;
foreach (FlowElement flowElement in process.FlowElements)
{
if (flowElement is StartEvent startEvent)
{
if (CollectionUtil.IsNotEmpty(startEvent.EventDefinitions) && startEvent.EventDefinitions[0] is MessageEventDefinition)
{
MessageEventDefinition messageEventDefinition = (MessageEventDefinition)startEvent.EventDefinitions[0];
if (messageEventDefinition.MessageRef.Equals(messageName))
{
initialFlowElement = flowElement;
break;
}
}
}
}
if (initialFlowElement == null)
{
throw new ActivitiException("No message start event found for process definition " + processDefinition.Id + " and message name " + messageName);
}
return(CreateAndStartProcessInstanceWithInitialFlowElement(processDefinition, null, null, initialFlowElement, process, variables, transientVariables, true));
}
protected internal virtual void InsertMessageEvent(MessageEventDefinition messageEventDefinition, StartEvent startEvent, IProcessDefinitionEntity processDefinition, BpmnModel bpmnModel)
{
ICommandContext commandContext = Context.CommandContext;
if (bpmnModel.ContainsMessageId(messageEventDefinition.MessageRef))
{
Message message = bpmnModel.GetMessage(messageEventDefinition.MessageRef);
messageEventDefinition.MessageRef = message.Name;
}
// look for subscriptions for the same name in db:
IList <IEventSubscriptionEntity> subscriptionsForSameMessageName = commandContext.EventSubscriptionEntityManager.FindEventSubscriptionsByName(MessageEventHandler.EVENT_HANDLER_TYPE, messageEventDefinition.MessageRef, processDefinition.TenantId);
foreach (IEventSubscriptionEntity eventSubscriptionEntity in subscriptionsForSameMessageName)
{
// throw exception only if there's already a subscription as start event
if (eventSubscriptionEntity.ProcessInstanceId is null || eventSubscriptionEntity.ProcessInstanceId.Length == 0)
{
// processInstanceId != null or not empty -> it's a message related to an execution
// the event subscription has no instance-id, so it's a message start event
throw new ActivitiException("Cannot deploy process definition '" + processDefinition.ResourceName + "': there already is a message event subscription for the message with name '" + messageEventDefinition.MessageRef + "'.");
}
}
IMessageEventSubscriptionEntity newSubscription = commandContext.EventSubscriptionEntityManager.CreateMessageEventSubscription();
newSubscription.EventName = messageEventDefinition.MessageRef;
newSubscription.ActivityId = startEvent.Id;
newSubscription.Configuration = processDefinition.Id;
newSubscription.ProcessDefinitionId = processDefinition.Id;
if (processDefinition.TenantId is object)
{
newSubscription.TenantId = processDefinition.TenantId;
}
commandContext.EventSubscriptionEntityManager.Insert(newSubscription);
}
protected internal virtual void restoreMessageStartEvent(IProcessDefinition previousProcessDefinition, BpmnModel bpmnModel, StartEvent startEvent, EventDefinition eventDefinition)
{
MessageEventDefinition messageEventDefinition = (MessageEventDefinition)eventDefinition;
if (bpmnModel.ContainsMessageId(messageEventDefinition.MessageRef))
{
Message message = bpmnModel.GetMessage(messageEventDefinition.MessageRef);
messageEventDefinition.MessageRef = message.Name;
}
IMessageEventSubscriptionEntity newSubscription = EventSubscriptionEntityManager.CreateMessageEventSubscription();
newSubscription.EventName = messageEventDefinition.MessageRef;
newSubscription.ActivityId = startEvent.Id;
newSubscription.Configuration = previousProcessDefinition.Id;
newSubscription.ProcessDefinitionId = previousProcessDefinition.Id;
if (!ReferenceEquals(previousProcessDefinition.TenantId, null))
{
newSubscription.TenantId = previousProcessDefinition.TenantId;
}
EventSubscriptionEntityManager.Insert(newSubscription);
}
protected internal virtual void WriteMessageDefinition(Event parentEvent, MessageEventDefinition messageDefinition, BpmnModel model, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_MESSAGEDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
string messageRef = messageDefinition.MessageRef;
if (!string.IsNullOrWhiteSpace(messageRef))
{
// remove the namespace from the message id if set
if (messageRef.StartsWith(model.TargetNamespace, StringComparison.Ordinal))
{
messageRef = messageRef.Replace(model.TargetNamespace, "");
messageRef = messageRef.ReplaceFirst(":", "");
}
else
{
foreach (string prefix in model.Namespaces.Keys)
{
string @namespace = model.GetNamespace(prefix);
if (messageRef.StartsWith(@namespace, StringComparison.Ordinal))
{
messageRef = messageRef.Replace(model.TargetNamespace, "");
messageRef = prefix + messageRef;
}
}
}
}
WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_MESSAGE_REF, messageRef, xtw);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(messageDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
public virtual EventSubProcessMessageStartEventActivityBehavior CreateEventSubProcessMessageStartEventActivityBehavior(StartEvent startEvent, MessageEventDefinition messageEventDefinition)
{
return(new EventSubProcessMessageStartEventActivityBehavior(messageEventDefinition));
}
public EventSubProcessMessageStartEventActivityBehavior(MessageEventDefinition messageEventDefinition)
{
this.messageEventDefinition = messageEventDefinition;
}
public override object Create(object parent, IParseContext context, XElement element)
{
EventDefinition eventDefinition = null;
var localName = Helper.GetRealLocalName(element);
switch (localName)
{
case "cancelEventDefinition":
eventDefinition = new CancelEventDefinition();
break;
case "errorEventDefinition":
var errorEventDefinition = new ErrorEventDefinition();
eventDefinition = errorEventDefinition;
var errorRef = element.GetAttribute("errorRef");
if (errorRef != null)
{
context.AddReferenceRequest <Error>(errorRef, x => errorEventDefinition.ErrorRef = x);
}
break;
case "timerEventDefinition":
eventDefinition = new TimerEventDefinition();
break;
case "terminateEventDefinition":
eventDefinition = new TerminateEventDefinition();
break;
case "messageEventDefinition":
var messageEventDefinition = new MessageEventDefinition();
eventDefinition = messageEventDefinition;
var operationRef = element.GetAttribute("operationRef");
if (operationRef != null)
{
context.AddReferenceRequest <Operation>(operationRef, x => messageEventDefinition.OperationRef = x);
}
var messageRef = element.GetAttribute("messageRef");
if (messageRef != null)
{
context.AddReferenceRequest <Message>(messageRef, x => messageEventDefinition.MessageRef = x);
}
break;
case "conditionalEventDefinition":
eventDefinition = new ConditionalEventDefinition();
break;
case "compensateEventDefinition":
var compensateEventDefinition = new CompensateEventDefinition();
eventDefinition = compensateEventDefinition;
compensateEventDefinition.WaitForCompletion = element.GetBoolean("waitForCompletion");
var activityRef = element.GetAttribute("activityRef");
if (activityRef != null)
{
context.AddReferenceRequest <Activity>(activityRef, x => compensateEventDefinition.ActivityRef = x);
}
break;
case "signalEventDefinition":
var signalEventDefinition = new SignalEventDefinition();
eventDefinition = signalEventDefinition;
var signalRef = element.GetAttribute("signalRef");
if (signalRef != null)
{
context.AddReferenceRequest <Signal>(signalRef, x => signalEventDefinition.SignalRef = x);
}
break;
case "escalationEventDefinition":
eventDefinition = new EscalationEventDefinition()
{
EscalationRef = element.GetAttribute("escalationRef")
};
break;
case "linkEventDefinition":
eventDefinition = new LinkEventDefinition()
{
Name = element.GetAttribute("name"),
Target = element.GetAttribute("target")
};
break;
}
if (this.callback != null)
{
this.callback(parent, context, element, eventDefinition);
}
base.Init(eventDefinition, context, element);
context.Push(eventDefinition);
return(eventDefinition);
}
public AbstractMessageEventDefinitionBuilder(BpmnModelInstance modelInstance, MessageEventDefinition element, Type selfType) : base(modelInstance, element, selfType)
{
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldAddMessageAndMessageEventDefinition()
public virtual void shouldAddMessageAndMessageEventDefinition()
{
// create empty model
BpmnModelInstance bpmnModelInstance = Bpmn.createEmptyModel();
// add definitions to model
Definitions definitions = bpmnModelInstance.newInstance(typeof(Definitions));
definitions.TargetNamespace = "Examples";
bpmnModelInstance.Definitions = definitions;
// create and add message
Message message = bpmnModelInstance.newInstance(typeof(Message));
message.Id = "start-message-id";
definitions.RootElements.Add(message);
// create and add message event definition
MessageEventDefinition messageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
messageEventDefinition.Id = "message-event-def-id";
messageEventDefinition.Message = message;
definitions.RootElements.Add(messageEventDefinition);
// test if message was set correctly
Message setMessage = messageEventDefinition.Message;
assertThat(setMessage).isEqualTo(message);
// add process
Process process = bpmnModelInstance.newInstance(typeof(Process));
process.Id = "messageEventDefinition";
definitions.RootElements.Add(process);
// add start event
StartEvent startEvent = bpmnModelInstance.newInstance(typeof(StartEvent));
startEvent.Id = "theStart";
process.FlowElements.Add(startEvent);
// create and add message event definition to start event
MessageEventDefinition startEventMessageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
startEventMessageEventDefinition.Message = message;
startEvent.EventDefinitions.Add(startEventMessageEventDefinition);
// create another message but do not add it
Message anotherMessage = bpmnModelInstance.newInstance(typeof(Message));
anotherMessage.Id = "another-message-id";
// create a message event definition and try to add last create message
MessageEventDefinition anotherMessageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
try
{
anotherMessageEventDefinition.Message = anotherMessage;
Assert.fail("Message should not be added to message event definition, cause it is not part of the model");
}
catch (Exception e)
{
assertThat(e).isInstanceOf(typeof(ModelReferenceException));
}
// first add message to model than to event definition
definitions.RootElements.Add(anotherMessage);
anotherMessageEventDefinition.Message = anotherMessage;
startEvent.EventDefinitions.Add(anotherMessageEventDefinition);
// message event definition and add message by id to it
anotherMessageEventDefinition = bpmnModelInstance.newInstance(typeof(MessageEventDefinition));
startEvent.EventDefinitions.Add(anotherMessageEventDefinition);
// validate model
try
{
Bpmn.validateModel(bpmnModelInstance);
}
catch (ModelValidationException)
{
Assert.fail();
}
}
public BoundaryMessageEventActivityBehavior(MessageEventDefinition messageEventDefinition, bool interrupting) : base(interrupting)
{
this.messageEventDefinition = messageEventDefinition;
}
protected internal override void ExecuteValidation(BpmnModel bpmnModel, Process process, IList <ValidationError> errors)
{
IList <BoundaryEvent> boundaryEvents = process.FindFlowElementsOfType <BoundaryEvent>();
// Only one boundary event of type 'cancel' can be attached to the same
// element, so we store the count temporarily here
Dictionary <string, int> cancelBoundaryEventsCounts = new Dictionary <string, int>();
// Only one boundary event of type 'compensate' can be attached to the
// same element, so we store the count temporarily here
Dictionary <string, int> compensateBoundaryEventsCounts = new Dictionary <string, int>();
for (int i = 0; i < boundaryEvents.Count; i++)
{
BoundaryEvent boundaryEvent = boundaryEvents[i];
if (boundaryEvent.EventDefinitions != null && boundaryEvent.EventDefinitions.Count > 0)
{
EventDefinition eventDefinition = boundaryEvent.EventDefinitions[0];
if (!(eventDefinition is TimerEventDefinition) && !(eventDefinition is ErrorEventDefinition) && !(eventDefinition is SignalEventDefinition) && !(eventDefinition is CancelEventDefinition) && !(eventDefinition is MessageEventDefinition) && !(eventDefinition is CompensateEventDefinition))
{
AddError(errors, ProblemsConstants.BOUNDARY_EVENT_INVALID_EVENT_DEFINITION, process, boundaryEvent, ProcessValidatorResource.BOUNDARY_EVENT_INVALID_EVENT_DEFINITION);
}
if (eventDefinition is CancelEventDefinition)
{
FlowElement attachedToFlowElement = bpmnModel.GetFlowElement(boundaryEvent.AttachedToRefId);
if (!(attachedToFlowElement is Transaction))
{
AddError(errors, ProblemsConstants.BOUNDARY_EVENT_CANCEL_ONLY_ON_TRANSACTION, process, boundaryEvent, ProcessValidatorResource.BOUNDARY_EVENT_CANCEL_ONLY_ON_TRANSACTION);
}
else
{
if (!cancelBoundaryEventsCounts.ContainsKey(attachedToFlowElement.Id))
{
cancelBoundaryEventsCounts[attachedToFlowElement.Id] = 0;
}
cancelBoundaryEventsCounts[attachedToFlowElement.Id] = cancelBoundaryEventsCounts[attachedToFlowElement.Id] + 1;
}
}
else if (eventDefinition is CompensateEventDefinition)
{
if (!compensateBoundaryEventsCounts.ContainsKey(boundaryEvent.AttachedToRefId))
{
compensateBoundaryEventsCounts[boundaryEvent.AttachedToRefId] = 0;
}
compensateBoundaryEventsCounts[boundaryEvent.AttachedToRefId] = compensateBoundaryEventsCounts[boundaryEvent.AttachedToRefId] + 1;
}
else if (eventDefinition is MessageEventDefinition)
{
// Check if other message boundary events with same message
// id
for (int j = 0; j < boundaryEvents.Count; j++)
{
if (j != i)
{
BoundaryEvent otherBoundaryEvent = boundaryEvents[j];
if (otherBoundaryEvent.AttachedToRefId is object && otherBoundaryEvent.AttachedToRefId.Equals(boundaryEvent.AttachedToRefId))
{
if (otherBoundaryEvent.EventDefinitions != null && otherBoundaryEvent.EventDefinitions.Count > 0)
{
EventDefinition otherEventDefinition = otherBoundaryEvent.EventDefinitions[0];
if (otherEventDefinition is MessageEventDefinition)
{
MessageEventDefinition currentMessageEventDefinition = (MessageEventDefinition)eventDefinition;
MessageEventDefinition otherMessageEventDefinition = (MessageEventDefinition)otherEventDefinition;
if (otherMessageEventDefinition.MessageRef is object && otherMessageEventDefinition.MessageRef.Equals(currentMessageEventDefinition.MessageRef))
{
AddError(errors, ProblemsConstants.MESSAGE_EVENT_MULTIPLE_ON_BOUNDARY_SAME_MESSAGE_ID, process, boundaryEvent, ProcessValidatorResource.MESSAGE_EVENT_MULTIPLE_ON_BOUNDARY_SAME_MESSAGE_ID);
}
}
}
}
}
}
}
}
else
{
AddError(errors, ProblemsConstants.BOUNDARY_EVENT_NO_EVENT_DEFINITION, process, boundaryEvent, "Event definition is missing from boundary event");
}
}
foreach (string elementId in cancelBoundaryEventsCounts.Keys)
{
if (cancelBoundaryEventsCounts[elementId] > 1)
{
AddError(errors, ProblemsConstants.BOUNDARY_EVENT_MULTIPLE_CANCEL_ON_TRANSACTION, process, bpmnModel.GetFlowElement(elementId), "multiple boundary events with cancelEventDefinition not supported on same transaction subprocess.");
}
}
foreach (string elementId in compensateBoundaryEventsCounts.Keys)
{
if (compensateBoundaryEventsCounts[elementId] > 1)
{
AddError(errors, ProblemsConstants.COMPENSATE_EVENT_MULTIPLE_ON_BOUNDARY, process, bpmnModel.GetFlowElement(elementId), "Multiple boundary events of type 'compensate' is invalid");
}
}
}
public IntermediateCatchMessageEventActivityBehavior(MessageEventDefinition messageEventDefinition)
{
this.messageEventDefinition = messageEventDefinition;
}
public virtual BoundaryMessageEventActivityBehavior CreateBoundaryMessageEventActivityBehavior(BoundaryEvent boundaryEvent, MessageEventDefinition messageEventDefinition, bool interrupting)
{
return(new BoundaryMessageEventActivityBehavior(messageEventDefinition, interrupting));
}
public virtual IntermediateThrowMessageEventActivityBehavior CreateIntermediateThrowMessgeEventActivityBehavior(ThrowEvent throwEvent, MessageEventDefinition messageEventDefinition, Message message)
{
return(new IntermediateThrowMessageEventActivityBehavior(messageEventDefinition, message));
}
public virtual IntermediateCatchMessageEventActivityBehavior CreateIntermediateCatchMessageEventActivityBehavior(IntermediateCatchEvent intermediateCatchEvent, MessageEventDefinition messageEventDefinition)
{
return(new IntermediateCatchMessageEventActivityBehavior(messageEventDefinition));
}
