///
/// <summary>
/// +-----------------+
/// | Case1 \
/// +-------------------+-----------------+
/// | |
/// | +------------------------+ |
/// | / X \ |
/// | + +-------+ +-------+ + |
/// | | | A | | B | | |
/// | + +-------+ +-------+ + |
/// | \ / |
/// | +------------------------+ |
/// | |
/// +-------------------------------------+
///
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCloseStage()
public virtual void testCloseStage()
{
CaseExecutionStateTransitionCollector stateTransitionCollector = new CaseExecutionStateTransitionCollector();
// given
// a case definition
CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).listener("close", stateTransitionCollector).createActivity("X").behavior(new StageActivityBehavior()).createActivity("A").behavior(new TaskWaitState()).endActivity().createActivity("B").behavior(new TaskWaitState()).endActivity().endActivity().buildCaseDefinition();
// an active case instance
CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
caseInstance.create();
CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");
try
{
// when
stageX.close();
fail("It should not be possible to close a stage.");
}
catch (CaseIllegalStateTransitionException)
{
}
// then
assertTrue(stateTransitionCollector.stateTransitions.Count == 0);
assertTrue(caseInstance.Active);
assertNotNull(caseInstance.findCaseExecution("X"));
}
protected internal virtual void checkAndCompleteCaseExecution(CmmnActivityExecution execution)
{
if (canComplete(execution))
{
execution.complete();
}
}
// start /////////////////////////////////////////////////////////////////////
protected internal override void performStart(CmmnActivityExecution execution)
{
CmmnActivity activity = execution.Activity;
IList <CmmnActivity> childActivities = activity.Activities;
if (childActivities != null && childActivities.Count > 0)
{
IList <CmmnExecution> children = execution.createChildExecutions(childActivities);
execution.createSentryParts();
execution.triggerChildExecutionsLifecycle(children);
if (execution.Active)
{
execution.fireIfOnlySentryParts();
// if "autoComplete == true" and there are no
// required nor active child activities,
// then the stage will be completed.
if (execution.Active)
{
checkAndCompleteCaseExecution(execution);
}
}
}
else
{
execution.complete();
}
}
protected internal override void triggerCallableElement(CmmnActivityExecution execution, IDictionary <string, object> variables, string businessKey)
{
ProcessDefinitionImpl definition = getProcessDefinitionToCall(execution, CallableElement);
PvmProcessInstance processInstance = execution.createSubProcessInstance(definition, businessKey);
processInstance.start(variables);
}
public virtual void handleChildTermination(CmmnActivityExecution execution, CmmnActivityExecution child)
{
fireForceUpdate(execution);
if (execution.Active)
{
checkAndCompleteCaseExecution(execution);
}
else if (execution.Terminating && isAbleToTerminate(execution))
{
string id = execution.Id;
CaseExecutionState currentState = execution.CurrentState;
if (TERMINATING_ON_TERMINATION.Equals(currentState))
{
execution.performTerminate();
}
else if (TERMINATING_ON_EXIT.Equals(currentState))
{
execution.performExit();
}
else if (TERMINATING_ON_PARENT_TERMINATION.Equals(currentState))
{
throw LOG.illegalStateTransitionException("parentTerminate", id, TypeName);
}
else
{
throw LOG.terminateCaseException(id, currentState);
}
}
}
protected internal override void triggerCallableElement(CmmnActivityExecution execution, IDictionary <string, object> variables, string businessKey)
{
CmmnCaseDefinition definition = getCaseDefinitionToCall(execution, CallableElement);
CmmnCaseInstance caseInstance = execution.createSubCaseInstance(definition, businessKey);
caseInstance.create(variables);
}
// termination //////////////////////////////////////////////////////////////
protected internal virtual bool isAbleToTerminate(CmmnActivityExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends org.camunda.bpm.engine.impl.cmmn.execution.CmmnExecution> children = execution.getCaseExecutions();
IList <CmmnExecution> children = execution.CaseExecutions;
if (children != null && children.Count > 0)
{
foreach (CmmnExecution child in children)
{
// the guard "!child.isCompleted()" is needed,
// when an exitCriteria is triggered on a stage, and
// the referenced sentry contains an onPart to a child
// case execution which has defined as standardEvent "complete".
// In that case the completed child case execution is still
// in the list of child case execution of the parent case execution.
if (!child.Terminated && !child.Completed)
{
return(false);
}
}
}
return(true);
}
// helper //////////////////////////////////////////////////////////////////////
protected internal virtual void ensureTransitionAllowed(CmmnActivityExecution execution, CaseExecutionState expected, CaseExecutionState target, string transition)
{
string id = execution.Id;
CaseExecutionState currentState = execution.CurrentState;
// the state "suspending" or "terminating" will set immediately
// inside the corresponding AtomicOperation, that's why the
// previous state will be used to ensure that the transition
// is allowed.
if (execution.Terminating || execution.Suspending)
{
currentState = execution.PreviousState;
}
// is the case execution already in the target state
if (target.Equals(currentState))
{
throw LOG.isAlreadyInStateException(transition, id, target);
}
else
{
// is the case execution in the expected state
if (!expected.Equals(currentState))
{
throw LOG.unexpectedStateException(transition, id, expected, currentState);
}
}
}
protected internal virtual void resumeChildren(CmmnActivityExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends org.camunda.bpm.engine.impl.cmmn.execution.CmmnExecution> children = execution.getCaseExecutions();
IList <CmmnExecution> children = execution.CaseExecutions;
if (children != null && children.Count > 0)
{
foreach (CmmnExecution child in children)
{
CmmnActivityBehavior behavior = getActivityBehavior(child);
// during resuming the children, it can happen that a sentry
// will be satisfied, so that a child will terminated. these
// terminated child cannot be resumed, so ignore it.
if (!child.Terminated)
{
if (behavior is StageOrTaskActivityBehavior)
{
child.parentResume();
}
else
{ // behavior instanceof EventListenerOrMilestoneActivityBehavior
child.resume();
}
}
}
}
}
// repetition ///////////////////////////////////////////////////////////////
public virtual void repeat(CmmnActivityExecution execution, string standardEvent)
{
CmmnActivity activity = execution.Activity;
bool repeat = false;
if (activity.EntryCriteria.Count == 0)
{
IList <string> events = activity.Properties.get(CmmnProperties.REPEAT_ON_STANDARD_EVENTS);
if (events != null && events.Contains(standardEvent))
{
repeat = evaluateRepetitionRule(execution);
}
}
else
{
if (ENABLE.Equals(standardEvent) || START.Equals(standardEvent) || OCCUR.Equals(standardEvent))
{
repeat = evaluateRepetitionRule(execution);
}
}
if (repeat)
{
CmmnActivityExecution parent = execution.Parent;
// instantiate a new instance of given activity
IList <CmmnExecution> children = parent.createChildExecutions(Arrays.asList(activity));
// start the lifecycle of the new instance
parent.triggerChildExecutionsLifecycle(children);
}
}
protected internal virtual void ensureNotCaseInstance(CmmnActivityExecution execution, string transition)
{
if (execution.CaseInstanceExecution)
{
string id = execution.Id;
throw LOG.impossibleTransitionException(transition, id);
}
}
protected internal virtual void fireForceUpdate(CmmnActivityExecution execution)
{
if (execution is CaseExecutionEntity)
{
CaseExecutionEntity entity = (CaseExecutionEntity)execution;
entity.forceUpdate();
}
}
// sentry ///////////////////////////////////////////////////////////////////////////////
protected internal override bool isAtLeastOneEntryCriterionSatisfied(CmmnActivityExecution execution)
{
if (!execution.CaseInstanceExecution)
{
return(base.isAtLeastOneEntryCriterionSatisfied(execution));
}
return(false);
}
public virtual void handleChildDisabled(CmmnActivityExecution execution, CmmnActivityExecution child)
{
fireForceUpdate(execution);
if (execution.Active)
{
checkAndCompleteCaseExecution(execution);
}
}
protected internal virtual CmmnActivity getActivity(CmmnActivityExecution execution)
{
string id = execution.Id;
CmmnActivity activity = execution.Activity;
ensureNotNull(typeof(PvmException), "Case execution '" + id + "': has no current activity.", "activity", activity);
return(activity);
}
public virtual void resumed(CmmnActivityExecution execution)
{
if (execution.Available)
{
// trigger created() to check whether an exit- or
// entryCriteria has been satisfied in the meantime.
created(execution);
}
}
public override void fireEntryCriteria(CmmnActivityExecution execution)
{
if (!execution.CaseInstanceExecution)
{
base.fireEntryCriteria(execution);
return;
}
throw LOG.criteriaNotAllowedForCaseInstanceException("entry", execution.Id);
}
protected internal override void performParentSuspension(CmmnActivityExecution execution)
{
if (!isAbleToSuspend(execution))
{
suspendChildren(execution);
}
else
{
base.performParentSuspension(execution);
}
}
protected internal override void performExit(CmmnActivityExecution execution)
{
if (!isAbleToTerminate(execution))
{
terminateChildren(execution);
}
else
{
base.performExit(execution);
}
}
protected internal virtual void terminateChildren(CmmnActivityExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends org.camunda.bpm.engine.impl.cmmn.execution.CmmnExecution> children = execution.getCaseExecutions();
IList <CmmnExecution> children = execution.CaseExecutions;
foreach (CmmnExecution child in children)
{
terminateChild(child);
}
}
public override void fireExitCriteria(CmmnActivityExecution execution)
{
if (!execution.CaseInstanceExecution)
{
execution.exit();
}
else
{
execution.terminate();
}
}
protected internal override void performStart(CmmnActivityExecution execution)
{
VariableMap variables = getInputVariables(execution);
string businessKey = getBusinessKey(execution);
triggerCallableElement(execution, variables, businessKey);
if (execution.Active && !isBlocking(execution))
{
execution.complete();
}
}
// sentries //////////////////////////////////////////////////////////////////////////////
protected internal virtual bool isAtLeastOneEntryCriterionSatisfied(CmmnActivityExecution execution)
{
if (execution.EntryCriterionSatisfied)
{
return(true);
}
CmmnActivity activity = getActivity(execution);
IList <CmmnSentryDeclaration> criteria = activity.EntryCriteria;
return(!(criteria != null && criteria.Count > 0));
}
// rules (required and repetition rule) /////////////////////////////////////////
protected internal virtual void evaluateRequiredRule(CmmnActivityExecution execution)
{
CmmnActivity activity = execution.Activity;
object requiredRule = activity.getProperty(PROPERTY_REQUIRED_RULE);
if (requiredRule != null)
{
CaseControlRule rule = (CaseControlRule)requiredRule;
bool required = rule.evaluate(execution);
execution.Required = required;
}
}
protected internal virtual bool evaluateRepetitionRule(CmmnActivityExecution execution)
{
CmmnActivity activity = execution.Activity;
object repetitionRule = activity.getProperty(PROPERTY_REPETITION_RULE);
if (repetitionRule != null)
{
CaseControlRule rule = (CaseControlRule)repetitionRule;
return(rule.evaluate(execution));
}
return(false);
}
public override void reactivated(CmmnActivityExecution execution)
{
if (execution.CaseInstanceExecution)
{
CaseExecutionState previousState = execution.PreviousState;
if (SUSPENDED.Equals(previousState))
{
resumed(execution);
}
}
// at the moment it is not possible to re-activate a case execution
// because the state "FAILED" is not implemented.
}
// resume /////////////////////////////////////////////////////////////////////////
public override void resumed(CmmnActivityExecution execution)
{
if (execution.Available)
{
// trigger created() to check whether an exit- or
// entryCriteria has been satisfied in the meantime.
created(execution);
}
else if (execution.Active)
{
// if the given case execution is active after resuming,
// then propagate it to the children.
resumeChildren(execution);
}
}
protected internal virtual bool evaluateAutoComplete(CmmnActivityExecution execution)
{
CmmnActivity activity = getActivity(execution);
object autoCompleteProperty = activity.getProperty(PROPERTY_AUTO_COMPLETE);
if (autoCompleteProperty != null)
{
//JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method:
string message = "Property autoComplete expression returns non-Boolean: " + autoCompleteProperty + " (" + autoCompleteProperty.GetType().FullName + ")";
ensureInstanceOf(message, "autoComplete", autoCompleteProperty, typeof(Boolean));
return((bool?)autoCompleteProperty.Value);
}
return(false);
}
protected internal override void completing(CmmnActivityExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends org.camunda.bpm.engine.impl.cmmn.execution.CmmnExecution> children = execution.getCaseExecutions();
IList <CmmnExecution> children = execution.CaseExecutions;
foreach (CmmnExecution child in children)
{
if (!child.Disabled)
{
child.parentComplete();
}
else
{
child.remove();
}
}
}
protected internal virtual bool isAbleToSuspend(CmmnActivityExecution execution)
{
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.List<? extends org.camunda.bpm.engine.impl.cmmn.execution.CmmnExecution> children = execution.getCaseExecutions();
IList <CmmnExecution> children = execution.CaseExecutions;
if (children != null && children.Count > 0)
{
foreach (CmmnExecution child in children)
{
if (!child.Suspended)
{
return(false);
}
}
}
return(true);
}
