/// <summary>
/// Sets a catch compensation definition.
/// </summary>
/// <returns> the builder object </returns>
public virtual B compensation()
{
CompensateEventDefinition compensateEventDefinition = createCompensateEventDefinition();
element.EventDefinitions.add(compensateEventDefinition);
return(myself);
}
public override BaseElement Clone()
{
CompensateEventDefinition clone = new CompensateEventDefinition
{
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()
{
CompensateEventDefinition eventDefinition = eventDefinitionQuery.filterByType(typeof(CompensateEventDefinition)).singleResult();
assertThat(eventDefinition).NotNull;
assertThat(eventDefinition.WaitForCompletion).True;
assertThat(eventDefinition.Activity.Id).isEqualTo("task");
}
protected internal virtual void HandleCompensationEventDefinition(BpmnModel bpmnModel, Process process, Event @event, EventDefinition eventDefinition, IList <ValidationError> errors)
{
CompensateEventDefinition compensateEventDefinition = (CompensateEventDefinition)eventDefinition;
// Check activityRef
if ((!string.IsNullOrWhiteSpace(compensateEventDefinition.ActivityRef) && process.GetFlowElement(compensateEventDefinition.ActivityRef, true) == null))
{
AddError(errors, ProblemsConstants.COMPENSATE_EVENT_INVALID_ACTIVITY_REF, process, @event, ProcessValidatorResource.COMPENSATE_EVENT_INVALID_ACTIVITY_REF);
}
}
public virtual CompensateEventDefinitionBuilder compensateEventDefinition(string id)
{
CompensateEventDefinition eventDefinition = createInstance(typeof(CompensateEventDefinition));
if (!string.ReferenceEquals(id, null))
{
eventDefinition.Id = id;
}
element.EventDefinitions.add(eventDefinition);
return(new CompensateEventDefinitionBuilder(modelInstance, eventDefinition));
}
protected internal virtual void WriteCompensateDefinition(Event parentEvent, CompensateEventDefinition compensateEventDefinition, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_COMPENSATEDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_COMPENSATE_ACTIVITYREF, compensateEventDefinition.ActivityRef, xtw);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(compensateEventDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
public override void parseIntermediateThrowEvent(Element intermediateEventElement, ScopeImpl scope, ActivityImpl activity)
{
// Change activity behavior
Element compensateEventDefinitionElement = intermediateEventElement.element(COMPENSATE_EVENT_DEFINITION);
if (compensateEventDefinitionElement != null)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String activityRef = compensateEventDefinitionElement.attribute("activityRef");
string activityRef = compensateEventDefinitionElement.attribute("activityRef");
CompensateEventDefinition compensateEventDefinition = new CompensateEventDefinition();
compensateEventDefinition.ActivityRef = activityRef;
compensateEventDefinition.WaitForCompletion = false;
activity.ActivityBehavior = new TestCompensationEventActivityBehavior(this, compensateEventDefinition);
}
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
if (!(parentElement is Event))
{
return;
}
CompensateEventDefinition eventDefinition = new CompensateEventDefinition();
BpmnXMLUtil.AddXMLLocation(eventDefinition, xtr);
eventDefinition.ActivityRef = xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_COMPENSATE_ACTIVITYREF);
if (!string.IsNullOrWhiteSpace(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_COMPENSATE_WAITFORCOMPLETION)))
{
eventDefinition.WaitForCompletion = bool.Parse(xtr.GetAttributeValue(BpmnXMLConstants.ATTRIBUTE_COMPENSATE_WAITFORCOMPLETION));
}
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_EVENT_COMPENSATEDEFINITION, eventDefinition, xtr, model);
((Event)parentElement).EventDefinitions.Add(eventDefinition);
}
public CompensationEventActivityBehavior(CompensateEventDefinition compensateEventDefinition)
{
this.compensateEventDefinition = compensateEventDefinition;
}
public BoundaryCompensateEventActivityBehavior(CompensateEventDefinition compensateEventDefinition, bool interrupting) : base(interrupting)
{
this.compensateEventDefinition = compensateEventDefinition;
}
public AbstractCompensateEventDefinitionBuilder(BpmnModelInstance modelInstance, CompensateEventDefinition element, Type selfType) : base(modelInstance, element, selfType)
{
}
public virtual IntermediateThrowCompensationEventActivityBehavior CreateIntermediateThrowCompensationEventActivityBehavior(ThrowEvent throwEvent, CompensateEventDefinition compensateEventDefinition)
{
return(new IntermediateThrowCompensationEventActivityBehavior(compensateEventDefinition));
}
public IntermediateThrowCompensationEventActivityBehavior(CompensateEventDefinition compensateEventDefinition)
{
this.compensateEventDefinition = compensateEventDefinition;
}
public TestCompensationEventActivityBehavior(TestBPMNParseListener outerInstance, CompensateEventDefinition compensateEventDefinition) : base(compensateEventDefinition)
{
this.outerInstance = outerInstance;
}
protected internal virtual CompensateEventDefinition createCompensateEventDefinition()
{
CompensateEventDefinition compensateEventDefinition = createInstance(typeof(CompensateEventDefinition));
return(compensateEventDefinition);
}
public virtual BoundaryCompensateEventActivityBehavior CreateBoundaryCompensateEventActivityBehavior(BoundaryEvent boundaryEvent, CompensateEventDefinition compensateEventDefinition, bool interrupting)
{
return(new BoundaryCompensateEventActivityBehavior(compensateEventDefinition, interrupting));
}
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);
}
