/// <summary>
/// Creates an error event definition
/// and returns a builder for the error event definition.
/// </summary>
/// <returns> the error event definition builder object </returns>
public virtual ErrorEventDefinitionBuilder errorEventDefinition()
{
ErrorEventDefinition errorEventDefinition = createEmptyErrorEventDefinition();
element.EventDefinitions.add(errorEventDefinition);
return(new ErrorEventDefinitionBuilder(modelInstance, errorEventDefinition));
}
//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()
{
ErrorEventDefinition eventDefinition = eventDefinitionQuery.filterByType(typeof(ErrorEventDefinition)).singleResult();
assertThat(eventDefinition).NotNull;
assertThat(eventDefinition.Error.Id).isEqualTo("error");
}
/// <summary>
/// Sets an error definition for the given error code. If already an error
/// with this code exists it will be used, otherwise a new error is created.
/// </summary>
/// <param name="errorCode"> the code of the error </param>
/// <returns> the builder object </returns>
public virtual B error(string errorCode)
{
ErrorEventDefinition errorEventDefinition = createErrorEventDefinition(errorCode);
element.EventDefinitions.add(errorEventDefinition);
return(myself);
}
/// <summary>
/// Sets a catch all error definition.
/// </summary>
/// <returns> the builder object </returns>
public virtual B error()
{
ErrorEventDefinition errorEventDefinition = createInstance(typeof(ErrorEventDefinition));
element.EventDefinitions.add(errorEventDefinition);
return(myself);
}
protected internal virtual ErrorEventDefinition createErrorEventDefinition(string errorCode)
{
Error error = findErrorForNameAndCode(errorCode);
ErrorEventDefinition errorEventDefinition = createInstance(typeof(ErrorEventDefinition));
errorEventDefinition.Error = error;
return(errorEventDefinition);
}
public override BaseElement Clone()
{
ErrorEventDefinition clone = new ErrorEventDefinition
{
Values = this
};
return(clone);
}
protected internal virtual void WriteErrorDefinition(Event parentEvent, ErrorEventDefinition errorDefinition, XMLStreamWriter xtw)
{
xtw.WriteStartElement(BpmnXMLConstants.BPMN_PREFIX, BpmnXMLConstants.ELEMENT_EVENT_ERRORDEFINITION, BpmnXMLConstants.BPMN2_NAMESPACE);
WriteDefaultAttribute(BpmnXMLConstants.ATTRIBUTE_ERROR_REF, errorDefinition.ErrorCode, xtw);
bool didWriteExtensionStartElement = BpmnXMLUtil.WriteExtensionElements(errorDefinition, false, xtw);
if (didWriteExtensionStartElement)
{
xtw.WriteEndElement();
}
xtw.WriteEndElement();
}
/// <summary>
/// Creates an error event definition with an unique id
/// and returns a builder for the error event definition.
/// </summary>
/// <returns> the error event definition builder object </returns>
public virtual ErrorEventDefinitionBuilder errorEventDefinition(string id)
{
ErrorEventDefinition errorEventDefinition = createEmptyErrorEventDefinition();
if (!string.ReferenceEquals(id, null))
{
errorEventDefinition.Id = id;
}
element.EventDefinitions.add(errorEventDefinition);
return(new ErrorEventDefinitionBuilder(modelInstance, errorEventDefinition));
}
public virtual void visit(PvmScope scope)
{
IList <ErrorEventDefinition> errorEventDefinitions = scope.Properties.get(BpmnProperties.ERROR_EVENT_DEFINITIONS);
foreach (ErrorEventDefinition errorEventDefinition in errorEventDefinitions)
{
PvmActivity activityHandler = scope.ProcessDefinition.findActivity(errorEventDefinition.HandlerActivityId);
if ((!isReThrowingErrorEventSubprocess(activityHandler)) && ((exception != null && errorEventDefinition.catchesException(exception)) || (exception == null && errorEventDefinition.catchesError(errorCode))))
{
errorHandlerActivity = activityHandler;
this.errorEventDefinition = errorEventDefinition;
break;
}
}
}
public override void ParseChildElement(XMLStreamReader xtr, BaseElement parentElement, BpmnModel model)
{
if (!(parentElement is Event))
{
return;
}
ErrorEventDefinition eventDefinition = new ErrorEventDefinition();
BpmnXMLUtil.AddXMLLocation(eventDefinition, xtr);
eventDefinition.ErrorCode = xtr.GetAttributeValue("errorRef");
BpmnXMLUtil.ParseChildElements(BpmnXMLConstants.ELEMENT_EVENT_ERRORDEFINITION, eventDefinition, xtr, model);
((Event)parentElement).EventDefinitions.Add(eventDefinition);
}
public virtual void Visit(IPvmScope scope)
{
var errorEventDefinitions = scope.Properties.Get(BpmnProperties.ErrorEventDefinitions);
foreach (var errorEventDefinition in errorEventDefinitions)
{
var activityHandler = scope.ProcessDefinition.FindActivity(errorEventDefinition.HandlerActivityId);
if (!IsReThrowingErrorEventSubprocess(activityHandler) &&
(((Exception != null) && errorEventDefinition.CatchesException(Exception)) ||
((Exception == null) && errorEventDefinition.CatchesError(ErrorCode))))
{
errorHandlerActivity = activityHandler;
this.errorEventDefinition = errorEventDefinition;
break;
}
}
}
public AbstractErrorEventDefinitionBuilder(BpmnModelInstance modelInstance, ErrorEventDefinition element, Type selfType) : base(modelInstance, element, selfType)
{
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void propagateError(String errorCode, String errorMessage, Exception origException, org.camunda.bpm.engine.impl.pvm.delegate.ActivityExecution execution) throws Exception
public static void propagateError(string errorCode, string errorMessage, Exception origException, ActivityExecution execution)
{
ActivityExecutionHierarchyWalker walker = new ActivityExecutionHierarchyWalker(execution);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ErrorDeclarationForProcessInstanceFinder errorDeclarationFinder = new ErrorDeclarationForProcessInstanceFinder(origException, errorCode, execution.getActivity());
ErrorDeclarationForProcessInstanceFinder errorDeclarationFinder = new ErrorDeclarationForProcessInstanceFinder(origException, errorCode, execution.Activity);
ActivityExecutionMappingCollector activityExecutionMappingCollector = new ActivityExecutionMappingCollector(execution);
walker.addScopePreVisitor(errorDeclarationFinder);
walker.addExecutionPreVisitor(activityExecutionMappingCollector);
// map variables to super executions in the hierarchy of called process instances
walker.addExecutionPreVisitor(new OutputVariablesPropagator());
try
{
walker.walkUntil(new WalkConditionAnonymousInnerClass(errorDeclarationFinder));
}
catch (Exception e)
{
LOG.errorPropagationException(execution.ActivityInstanceId, e);
// separate the exception handling to support a fail-safe error propagation
throw new ErrorPropagationException(e.InnerException);
}
PvmActivity errorHandlingActivity = errorDeclarationFinder.ErrorHandlerActivity;
// process the error
if (errorHandlingActivity == null)
{
if (origException == null)
{
if (Context.CommandContext.ProcessEngineConfiguration.EnableExceptionsAfterUnhandledBpmnError)
{
throw LOG.missingBoundaryCatchEventError(execution.Activity.Id, errorCode);
}
else
{
LOG.missingBoundaryCatchEvent(execution.Activity.Id, errorCode);
execution.end(true);
}
}
else
{
// throw original exception
throw origException;
}
}
else
{
ErrorEventDefinition errorDefinition = errorDeclarationFinder.ErrorEventDefinition;
PvmExecutionImpl errorHandlingExecution = activityExecutionMappingCollector.getExecutionForScope(errorHandlingActivity.EventScope);
if (!string.ReferenceEquals(errorDefinition.ErrorCodeVariable, null))
{
errorHandlingExecution.setVariable(errorDefinition.ErrorCodeVariable, errorCode);
}
if (!string.ReferenceEquals(errorDefinition.ErrorMessageVariable, null))
{
errorHandlingExecution.setVariable(errorDefinition.ErrorMessageVariable, errorMessage);
}
errorHandlingExecution.executeActivity(errorHandlingActivity);
}
}
protected internal static IDictionary <string, IList <Event> > FindCatchingEventsForProcess(string processDefinitionId, string errorCode)
{
IDictionary <string, IList <Event> > eventMap = new Dictionary <string, IList <Event> >();
Process process = ProcessDefinitionUtil.GetProcess(processDefinitionId);
BpmnModel bpmnModel = ProcessDefinitionUtil.GetBpmnModel(processDefinitionId);
string compareErrorCode = RetrieveErrorCode(bpmnModel, errorCode);
IList <EventSubProcess> subProcesses = process.FindFlowElementsOfType <EventSubProcess>(true);
foreach (EventSubProcess eventSubProcess in subProcesses)
{
foreach (FlowElement flowElement in eventSubProcess.FlowElements)
{
if (flowElement is StartEvent startEvent)
{
if (CollectionUtil.IsNotEmpty(startEvent.EventDefinitions) && startEvent.EventDefinitions[0] is ErrorEventDefinition)
{
ErrorEventDefinition errorEventDef = (ErrorEventDefinition)startEvent.EventDefinitions[0];
string eventErrorCode = RetrieveErrorCode(bpmnModel, errorEventDef.ErrorCode);
if (eventErrorCode is null || compareErrorCode is null || eventErrorCode.Equals(compareErrorCode))
{
IList <Event> startEvents = new List <Event>
{
startEvent
};
eventMap[eventSubProcess.Id] = startEvents;
}
}
}
}
}
IList <BoundaryEvent> boundaryEvents = process.FindFlowElementsOfType <BoundaryEvent>(true);
foreach (BoundaryEvent boundaryEvent in boundaryEvents)
{
if (boundaryEvent.AttachedToRefId is object && CollectionUtil.IsNotEmpty(boundaryEvent.EventDefinitions) && boundaryEvent.EventDefinitions[0] is ErrorEventDefinition)
{
ErrorEventDefinition errorEventDef = (ErrorEventDefinition)boundaryEvent.EventDefinitions[0];
string eventErrorCode = RetrieveErrorCode(bpmnModel, errorEventDef.ErrorCode);
if (eventErrorCode is null || compareErrorCode is null || eventErrorCode.Equals(compareErrorCode))
{
IList <Event> elementBoundaryEvents = null;
if (!eventMap.ContainsKey(boundaryEvent.AttachedToRefId))
{
elementBoundaryEvents = new List <Event>();
eventMap[boundaryEvent.AttachedToRefId] = elementBoundaryEvents;
}
else
{
elementBoundaryEvents = eventMap[boundaryEvent.AttachedToRefId];
}
elementBoundaryEvents.Add(boundaryEvent);
}
}
}
return(eventMap);
}
public virtual ErrorEndEventActivityBehavior CreateErrorEndEventActivityBehavior(EndEvent endEvent, ErrorEventDefinition errorEventDefinition)
{
return(new ErrorEndEventActivityBehavior(errorEventDefinition.ErrorCode));
}
protected internal virtual ErrorEventDefinition createEmptyErrorEventDefinition()
{
ErrorEventDefinition errorEventDefinition = createInstance(typeof(ErrorEventDefinition));
return(errorEventDefinition);
}
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);
}
