/// /// <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); }