public virtual void created(CmmnActivityExecution execution)
{
if (execution.Available && isAtLeastOneEntryCriterionSatisfied(execution))
{
fireEntryCriteria(execution);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSuspendTask()
public virtual void testSuspendTask()
{
// given ///////////////////////////////////////////////////////////////
// a case definition
CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).createActivity("X").behavior(new StageActivityBehavior()).createActivity("A").behavior(new TaskWaitState()).endActivity().createActivity("B").behavior(new TaskWaitState()).property(ItemHandler.PROPERTY_MANUAL_ACTIVATION_RULE, defaultManualActivation()).endActivity().endActivity().buildCaseDefinition();
// an active case instance
CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
caseInstance.create();
// a case execution associated with Stage X
CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");
// a case execution associated with Task A
CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");
// a case execution associated with Task B
CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");
// when
taskA.suspend();
// then
assertTrue(caseInstance.Active);
assertTrue(stageX.Active);
assertTrue(taskA.Suspended);
assertTrue(taskB.Enabled);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testSuspendStage()
public virtual void testSuspendStage()
{
// given ///////////////////////////////////////////////////////////////
// a case definition
CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).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();
// a case execution associated with Stage X
CmmnActivityExecution stageX = caseInstance.findCaseExecution("X");
// a case execution associated with Task A
CmmnActivityExecution taskA = caseInstance.findCaseExecution("A");
// a case execution associated with Task B
CmmnActivityExecution taskB = caseInstance.findCaseExecution("B");
// when
stageX.suspend();
// then
assertTrue(caseInstance.Active);
assertTrue(stageX.Suspended);
assertTrue(taskA.Suspended);
assertTrue(taskB.Suspended);
}
protected internal override void completing(CmmnActivityExecution execution)
{
TaskEntity task = getTask(execution);
if (task != null)
{
task.caseExecutionCompleted();
}
}
public override void onParentTermination(CmmnActivityExecution execution)
{
if (execution.Completed)
{
string id = execution.Id;
throw LOG.executionAlreadyCompletedException("parentTerminate", id);
}
performParentTerminate(execution);
}
public virtual void created(CmmnActivityExecution execution)
{
// TODO: implement this:
// (1) in case of a UserEventListener there is nothing to do!
// (2) in case of TimerEventListener we have to check
// whether the timer must be triggered, when a transition
// on another plan item or case file item happens!
}
public override void onManualCompletion(CmmnActivityExecution execution)
{
// Throw always an exception!
// It should not be possible to complete a calling
// task manually. If the called instance has
// been completed, the associated task will
// be notified to complete automatically.
string id = execution.Id;
throw LOG.forbiddenManualCompletitionException("complete", id, TypeName);
}
protected internal virtual bool isBlocking(CmmnActivityExecution execution)
{
CmmnActivity activity = execution.Activity;
object isBlockingProperty = activity.getProperty(PROPERTY_IS_BLOCKING);
if (isBlockingProperty != null && isBlockingProperty is bool?)
{
return((bool?)isBlockingProperty.Value);
}
return(false);
}
protected internal virtual void terminating(CmmnActivityExecution execution)
{
TaskEntity task = getTask(execution);
// it can happen that a there does not exist
// a task, because the given execution was never
// active.
if (task != null)
{
task.delete("terminated", false);
}
}
public override void started(CmmnActivityExecution execution)
{
// only perform start behavior, when this case execution is
// still active.
// it can happen that a exit sentry will be triggered, so that
// the given case execution will be terminated, in that case we
// do not need to perform the start behavior
if (execution.Active)
{
performStart(execution);
}
}
// manual activation rule //////////////////////////////////////////////
protected internal virtual bool evaluateManualActivationRule(CmmnActivityExecution execution)
{
bool manualActivation = false;
CmmnActivity activity = execution.Activity;
object manualActivationRule = activity.getProperty(PROPERTY_MANUAL_ACTIVATION_RULE);
if (manualActivationRule != null)
{
CaseControlRule rule = (CaseControlRule)manualActivationRule;
manualActivation = rule.evaluate(execution);
}
return(manualActivation);
}
// sentry ///////////////////////////////////////////////////////////////
public override void fireEntryCriteria(CmmnActivityExecution execution)
{
bool manualActivation = evaluateManualActivationRule(execution);
if (manualActivation)
{
execution.enable();
}
else
{
execution.start();
}
}
public override void onExit(CmmnActivityExecution execution)
{
string id = execution.Id;
if (execution.Terminated)
{
throw LOG.alreadyTerminatedException("exit", id);
}
if (execution.Completed)
{
throw LOG.wrongCaseStateException("exit", id, "[available|enabled|disabled|active|failed|suspended]", "completed");
}
performExit(execution);
}
// resume ////////////////////////////////////////////////////////////////
public override void onResume(CmmnActivityExecution execution)
{
ensureTransitionAllowed(execution, SUSPENDED, AVAILABLE, "resume");
CmmnActivityExecution parent = execution.Parent;
if (parent != null)
{
if (!parent.Active)
{
string id = execution.Id;
throw LOG.resumeInactiveCaseException("resume", id);
}
}
resuming(execution);
}
public override void onParentSuspension(CmmnActivityExecution execution)
{
ensureNotCaseInstance(execution, "parentSuspension");
string id = execution.Id;
if (execution.Suspended)
{
throw LOG.alreadySuspendedException("parentSuspend", id);
}
if (execution.Completed || execution.Terminated)
{
throw LOG.wrongCaseStateException("parentSuspend", id, "suspend", "[available|enabled|disabled|active]", execution.CurrentState.ToString());
}
performParentSuspension(execution);
}
public virtual bool evaluate(CmmnActivityExecution execution)
{
if (expression == null)
{
return(true);
}
object result = expression.getValue(execution);
ensureNotNull("rule expression returns null", "result", result);
if (!(result is bool?))
{
throw LOG.ruleExpressionNotBooleanException(result);
}
return((bool?)result.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testOccurMilestone()
public virtual void testOccurMilestone()
{
// given
// a case definition
CmmnCaseDefinition caseDefinition = (new CaseDefinitionBuilder("Case1")).createActivity("A").behavior(new MilestoneActivityBehavior()).endActivity().buildCaseDefinition();
CmmnActivity activity = caseDefinition.findActivity("A");
// a pseudo sentry
CmmnSentryDeclaration sentryDeclaration = new CmmnSentryDeclaration("X");
caseDefinition.findActivity("Case1").addSentry(sentryDeclaration);
activity.addEntryCriteria(sentryDeclaration);
CmmnOnPartDeclaration onPartDeclaration = new CmmnOnPartDeclaration();
onPartDeclaration.Source = new CmmnActivity("B", caseDefinition);
onPartDeclaration.StandardEvent = "complete";
sentryDeclaration.addOnPart(onPartDeclaration);
// an active case instance
CmmnCaseInstance caseInstance = caseDefinition.createCaseInstance();
caseInstance.create();
// task A as a child of the case instance
CmmnActivityExecution milestoneA = caseInstance.findCaseExecution("A");
// when
// completing
milestoneA.occur();
// then
// task A is completed ...
assertTrue(milestoneA.Completed);
// ... and the case instance is also completed
assertTrue(caseInstance.Completed);
// task A is not part of the case instance anymore
assertNull(caseInstance.findCaseExecution("A"));
// the case instance has no children
assertTrue(((CaseExecutionImpl)caseInstance).CaseExecutions.Count == 0);
}
public override void onParentResume(CmmnActivityExecution execution)
{
ensureNotCaseInstance(execution, "parentResume");
string id = execution.Id;
if (!execution.Suspended)
{
throw LOG.wrongCaseStateException("parentResume", id, "resume", "suspended", execution.CurrentState.ToString());
}
CmmnActivityExecution parent = execution.Parent;
if (parent != null)
{
if (!parent.Active)
{
throw LOG.resumeInactiveCaseException("parentResume", id);
}
}
resuming(execution);
}
// termination ////////////////////////////////////////////////////////
public override void onTermination(CmmnActivityExecution execution)
{
ensureTransitionAllowed(execution, AVAILABLE, TERMINATED, "terminate");
performTerminate(execution);
}
public override void onManualCompletion(CmmnActivityExecution execution)
{
throw createIllegalStateTransitionException("complete", execution);
}
public override void onManualStart(CmmnActivityExecution execution)
{
throw createIllegalStateTransitionException("manualStart", execution);
}
// disable ///////////////////////////////////////////////////////////
public override void onDisable(CmmnActivityExecution execution)
{
throw createIllegalStateTransitionException("disable", execution);
}
// helper ////////////////////////////////////////////////////////////////
protected internal virtual CaseIllegalStateTransitionException createIllegalStateTransitionException(string transition, CmmnActivityExecution execution)
{
string id = execution.Id;
return(LOG.illegalStateTransitionException(transition, id, TypeName));
}
public override void fireExitCriteria(CmmnActivityExecution execution)
{
throw LOG.criteriaNotAllowedForEventListenerOrMilestonesException("exit", execution.Id);
}
// sentry ///////////////////////////////////////////////////////////////
protected internal virtual bool isAtLeastOneExitCriterionSatisfied(CmmnActivityExecution execution)
{
return(false);
}
protected internal virtual int?getVersion(CmmnActivityExecution execution)
{
CmmnExecution caseExecution = (CmmnExecution)execution;
return(CallableElement.getVersion(caseExecution));
}
protected internal virtual string getDefinitionKey(CmmnActivityExecution execution)
{
CmmnExecution caseExecution = (CmmnExecution)execution;
return(CallableElement.getDefinitionKey(caseExecution));
}
public override void onParentResume(CmmnActivityExecution execution)
{
throw createIllegalStateTransitionException("parentResume", execution);
}
protected internal virtual string getDeploymentId(CmmnActivityExecution execution)
{
return(CallableElement.DeploymentId);
}
// re-activation ////////////////////////////////////////////////////////
public override void onReactivation(CmmnActivityExecution execution)
{
throw createIllegalStateTransitionException("reactivate", execution);
}
