// sequential multi instance /////////////////////////////////
public static bool eventSubprocessComplete(ActivityExecution scopeExecution)
{
bool performLegacyBehavior = isLegacyBehaviorRequired(scopeExecution);
if (performLegacyBehavior)
{
LOG.completeNonScopeEventSubprocess();
scopeExecution.end(false);
}
return(performLegacyBehavior);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public void execute(org.camunda.bpm.engine.impl.pvm.delegate.ActivityExecution execution) throws Exception
public virtual void execute(ActivityExecution execution)
{
IList <PvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
if (outgoingTransitions.Count == 0)
{
execution.end(true);
}
else
{
execution.leaveActivityViaTransition(outgoingTransitions[0]);
}
}
public virtual void complete(ActivityExecution execution)
{
IList <PvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
if (outgoingTransitions.Count == 0)
{
execution.end(true);
}
else
{
execution.leaveActivityViaTransitions(outgoingTransitions, Collections.EMPTY_LIST);
}
}
/*
* Incoming execution is transformed into an event scope,
* new, non-concurrent execution leaves activity
*/
public virtual void complete(ActivityExecution execution)
{
ActivityExecution outgoingExecution = execution.Parent.createExecution();
outgoingExecution.Concurrent = false;
outgoingExecution.Activity = execution.Activity;
// eventscope execution
execution.Concurrent = false;
execution.Active = false;
((PvmExecutionImpl)execution).EventScope = true;
IList <PvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
if (outgoingTransitions.Count == 0)
{
outgoingExecution.end(true);
}
else
{
outgoingExecution.leaveActivityViaTransitions(outgoingTransitions, Collections.EMPTY_LIST);
}
}
/// <summary>
/// Actual implementation of leaving an activity.
/// </summary>
/// <param name="execution">
/// The current execution context </param>
/// <param name="checkConditions">
/// Whether or not to check conditions before determining whether or
/// not to take a transition. </param>
protected internal virtual void performOutgoingBehavior(ActivityExecution execution, bool checkConditions, IList <ActivityExecution> reusableExecutions)
{
LOG.leavingActivity(execution.Activity.Id);
string defaultSequenceFlow = (string)execution.Activity.getProperty("default");
IList <PvmTransition> transitionsToTake = new List <PvmTransition>();
IList <PvmTransition> outgoingTransitions = execution.Activity.OutgoingTransitions;
foreach (PvmTransition outgoingTransition in outgoingTransitions)
{
if (string.ReferenceEquals(defaultSequenceFlow, null) || !outgoingTransition.Id.Equals(defaultSequenceFlow))
{
Condition condition = (Condition)outgoingTransition.getProperty(BpmnParse.PROPERTYNAME_CONDITION);
if (condition == null || !checkConditions || condition.evaluate(execution))
{
transitionsToTake.Add(outgoingTransition);
}
}
}
if (transitionsToTake.Count == 1)
{
execution.leaveActivityViaTransition(transitionsToTake[0]);
}
else if (transitionsToTake.Count >= 1)
{
if (reusableExecutions == null || reusableExecutions.Count == 0)
{
execution.leaveActivityViaTransitions(transitionsToTake, Arrays.asList(execution));
}
else
{
execution.leaveActivityViaTransitions(transitionsToTake, reusableExecutions);
}
}
else
{
if (!string.ReferenceEquals(defaultSequenceFlow, null))
{
PvmTransition defaultTransition = execution.Activity.findOutgoingTransition(defaultSequenceFlow);
if (defaultTransition != null)
{
execution.leaveActivityViaTransition(defaultTransition);
}
else
{
throw LOG.missingDefaultFlowException(execution.Activity.Id, defaultSequenceFlow);
}
}
else if (outgoingTransitions.Count > 0)
{
throw LOG.missingConditionalFlowException(execution.Activity.Id);
}
else
{
if (((ActivityImpl)execution.Activity).CompensationHandler && isAncestorCompensationThrowing(execution))
{
execution.endCompensation();
}
else
{
LOG.missingOutgoingSequenceFlow(execution.Activity.Id);
execution.end(true);
}
}
}
}
//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);
}
}
