All Classes and Interfaces
Class
Description
An abstract command supporting functionality around identity link management for case instances.
AbstractCmmnParseHandler<T extends org.flowable.cmmn.model.BaseElement>
An abstract base class for operations using criteria evaluation like entry / exit sentries, repetition rule and parent completion rule.
Operation that moves a given
PlanItemInstance to a terminal state (completed, terminated or failed).Deprecated.
AbstractPlanItemParseHandler<T extends org.flowable.cmmn.model.BaseElement>
This command is adding a listener to the event dispatcher of the case engine, either for specific event types or for all events.
Creates diagrams from case definitions.
Resets the end time and reactivates the historic case instance by changing its state.
The case reactivation builder implementation storing reactivation specific information and executing the reactivation command to reactivate a historical
case instance.
Callback implementation for a child case instance (started from a process instance) returning it's state change to its parent.
Callback implementation for a child case instance returning it's state change to its parent.
Callback implementation for a child case instance returning it's state change to its parent.
Helper class for HTTP handlers to allow class delegation.
Root interface for all classes implementing logic when the CMMN engine
decides the behavior for a plan item needs to be executed.
An annotation that can be used on test classes or as a meta annotation to use a custom configuration resource for the
FlowableCmmnExtension.TODO: many similarities with BpmnDeployer, see if it can be merged to the common module
An annotation that can be used on test and lifecycle methods to inject the id of the deployment deployed via
CmmnDeployment.Provides access to all services that expose CMMN and case management operations.
Enhances script traces with scope information for the cmmn engine.
Wrapper class around the
HistoricVariableInstanceQueryImpl from the variable service,
specialized for usage in CMMN.Contains logic that is shared by multiple classes around history.
Helper class for writing unit tests with the async executor.
An abstract base class for CMMN engine based operations supporting general functionalities.
Allows to hook into the parsing of one or more elements during the parsing of a CMMN case definition.
TaskBuilder implementationBehavior interface, like
CmmnActivityBehavior, when the CMMN engine
decides the behavior for a plan item needs to be executed and the behavior
acts as a wait state.Wrapper class around the
VariableInstanceQueryImpl from the variable service, specialized for usage in CMMN.A class holding the result from evaluating a stage or case plan model for completion.
Superclass for
CmmnActivityBehavior implementations that are part of the
core CMMN behaviors of the CMMN Engine.Superclass for
CmmnTriggerableActivityBehavior implementations that are part of the
core CMMN behaviors of the CMMN Engine.Creates new task by
TaskBuilderCreates a new dynamically injected plan item instance and adds it to the agenda for activation.
A specific create operation for plan items being created out of a repetition where the repetition rule is actually treated as part of the main plan item
and not within the create operation as it is usually been treated.
Note: only possible for event listener plan items.
This command dispatches an event within the case engine.
Default implementation for dynamically modify running CMMN based case instances and plan items.
Implementation of the case completed event.
Implements a CMMN case stage ending event, holding the case and stage instances as well as the ending state of the stage.
Implements a CMMN case stage started event, holding the case and stage instances.
JUnit Jupiter extension for the Flowable CmmnEngine and services initialization.
Convenience for CmmnEngine and services initialization in the form of a JUnit rule.
Convenience for annotation that activates the
FlowableCmmnExtension JUnit Jupiter annotation.A Helper for the Flowable
FlowableCmmnExtension that can be used within the JUnit Jupiter context store
and users can use it in the tests for easy modifying of the CmmnEngine time.CmmnActivityBehavior implementation for the CMMN Event Listener.Gives access to a deployed case diagram, e.g., a PNG image, through a stream of bytes.
Note: only possible for event listener plan items.
Implementation of the dynamically created and injected plan item into a running stage instance.
This function evaluates a plan item to be completed, which is most likely used on a plan item with a repetition rule to check, whether it has alreday
been completed before.
This function evaluates a stage to be completable, which is the case, if all required and active plan items are completed
Based on the MailActivityBehavior found in the bpmn engine, adapted for use in cmmn.
An abstract superclass for
Command implementations that want to verify the provided task is always active (ie.Implement this behavior interface if you want to hook into the end semantics of a plan item depending on its parent ending transition.
Behavior interface, like the
CmmnActivityBehavior and CmmnTriggerableActivityBehavior interfaces,
exposing even more low-level hookpoints to add custom logic.The type returned when evaluating a plan items control when creating or reactivating it during case model evaluation.
CmmnActivityBehavior used when 'delegateExpression' is used for a serviceTask.This objects holds the result from a loop through a list of plan items evaluating their entry criteria, repetition rule and activation.
ActivityBehavior that evaluates an expression when executed.
Deprecated.
Deprecated.
An interface for entities that have child
PlanItemInstances.Utility methods around a plan item container (most likely a stage or case plan model).
Deprecated.
Deprecated.
Deprecated.
A plan item instance builder used to create new plan item instances with different options.
Implements the plan item instance builder API.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Internal class used during criteria evaluation.
This operation reactivates a case model by first setting its reactivation event listener to active and triggering it, then in a second phase step through
all plan items having a reactivation sentry and reactivate them before the model is completely re-evaluated again for reactivation of the case.
The parse handler for the reactivation event listener, adding specific properties to the listener like to be ignored by the parent for completion as well
as an availability condition on the state of the case.
This command reactivates a history case instance by putting it back to the runtime and triggering the reactivation event on its CMMN model.
Reactivates a plan item as part of a case reactivation which is pretty similar to the
CreatePlanItemInstanceOperation, but uses a different transition
for the listeners as the newly created plan item instance is created as part of a reactivation process.This operation is initializing phase two of a case reactivation by reactivating the root plan item model for the case according the case model which means
that only plan items marked as eligible for reactivation will be recreated and evaluated for activation.
Command to remove the current assignee from a case instance.
Command to remove the current owner from a case instance.
This command removes an event listener from the case engine.
Static methods for working with CMMN and image resource names.
Implementation of ScriptActivity CMMN 2.0 PlanItem.
Implementation for the
<taskListener type="script" /> TaskListener extension.Command to set a new assignee on a case instance.
Command that changes the business key of an existing case instance.A command to set or change the name of a case instance.
Command to set a new owner on a case instance and return the previous one, if any.
CmmnActivityBehavior implementation for the CMMN extension Signal Event Listener.Whenever a plan item or event listener changes its state as part of a CMMN engine operation, its current state and transition is checked to be valid.
CmmnActivityBehavior implementation for the CMMN Timer Event Listener.CmmnActivityBehavior implementation for the CMMN User Event Listener.CmmnActivityBehavior implementation for the CMMN extension Variable Event Listener.