All Classes and Interfaces
Class
Description
Denotes an 'activity' in the sense of BPMN 2.0: a parent class for all tasks, subprocess and callActivity.
An abstract command supporting functionality around identity link management for case instances.
An abstract command with various common methods for the creation and modification of case start event subscriptions.
Helper class for bpmn constructs that allow class delegation.
Abstract base class for implementations of
AutoDeploymentStrategyDeploymentStrategy.A data association (Input or Output) between a source and a target
Abstract base class for implementations of
AutoDeploymentStrategy.Convenience class for external engines (IDM/DMN/Form/...) to work together with the process engine
while also sharing as much internal resources as possible.
AbstractEngineEntityManager<T extends AbstractEngineConfiguration,EntityImpl extends Entity,DM extends DataManager<EntityImpl>>
Abstract superclass for the common properties of all
Entity implementations.Abstract superclass for the common properties of all
Entity implementations.Abstract superclass for the common properties of all
Entity implementations.An abstract base class for operations using criteria evaluation like entry / exit sentries, repetition rule and parent completion rule.
Abstract base class for implementations of
AutoDeploymentStrategy.Abstract class that can be used as a base class for pluggable functions that can be used in the EL expressions
Custom form types should extend this abstract class.
Abstract job entity class.
Operation that moves a given
PlanItemInstance to a terminal state (completed, terminated or failed).Abstract superclass for all native query types.
Abstract superclass for all operation interfaces (which are
Runnable instances), exposing some shared helper methods and member fields to subclasses.Abstract base class for implementations of
AutoDeploymentStrategy
for the ProcessEngine.An abstract command supporting functionality around identity link management for process instances.
An abstract command with various common methods for the creation and modification of process start event subscriptions.
Abstract superclass for all query types.
Base class simplifying binding and evaluation of scriptable elements.
AbstractServiceEngineEntityManager<T extends AbstractServiceConfiguration,EntityImpl extends Entity,DM extends DataManager<EntityImpl>>
A Transformer is responsible of transforming an object into a different object
Abstract query class that adds methods to query for variable values.
Factory class used by the
BpmnParser and BpmnParse to instantiate the behaviour classes.author martin.grofcik
Represents one execution of an activity in the currently running process.
Programmatic querying for
ActivityInstances.Contains the possible properties which can be used in a
ActivityInstanceQuery.This command is adding a listener to the event dispatcher of the case engine, either for specific event types or for all events.
Command that adds an event-listener to the process engine.
Implementation of the BPMN 2.0 ad-hoc subprocess.
An BusinessCalendar implementation for cycle based schedules that takes into account a different daylight savings time zone than the one that the server is configured for.
Provides an interface for versioned due date resolvers.
Resolves a due date using the original due date resolver.
Resolves a due date taking into account the specified time zone.
A HttpDelete alternative that extends
HttpEntityEnclosingRequestBase to allow DELETE with a request bodyBuilder for creating new deployments, similar to the bpmn deployment builder.
Allows programmatic querying of
AppDeployments.Defines property resolution behavior on arrays.
Implementation of the BPMN 2.0 'assignment'
A
JobHandler implementation that asynchronously will end an execution asynchronously.Invoker responsible for submitting tasks to the task executor.
Any type of content that is be associated with a task or with a process instance.
Flowable Authentication context that can be implemented in different ways to hold and store the current authentication information.
Strategy interface for implementations of automatically deploying resources.
Base implementation of a
FlowableEventListener, used when creating event-listeners that are part of a BPMN definition.Base event listener that can be used when implementing an
FlowableEventListener to get notified when an entity is created, updated, deleted or if another entity-related event occurs.Base class for ExceptionHandlerAdvice controllers From http://spring.io/blog/2013/11/01/exception-handling-in-spring-mvc
Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Base implementation of the
HistoricTaskLogEntryBuilder interfaceAllows programmatic querying of
Jobs.Created by Pardo David on 5/12/2016.
Base implementation of the
TaskBuilder interfaceContains the possible properties that can be used in a
BatchPartQuery.Contains the possible properties that can be used in a
BatchQuery.Service which provides access to batch entities.
Defines property resolution behavior on objects using the JavaBeans component architecture.
Transforms a
BigDecimal to a StringBindings, usually created by a
Tree.XML
NamespaceContext containing the namespaces used by BPMN 2.0 XML documents.Helper class for implementing BPMN 2.0 activities, offering convenience methods specific to BPMN 2.0.
Methods for working with deployments.
Special exception that can be used to throw a BPMN Error from
JavaDelegates and expressions.An Interface defines a set of operations that are implemented by services external to the process.
Represents an implementation of a
BpmnInterfaceSpecific parsing of one BPMN 2.0 XML file, created by the
BpmnParser.Allows to hook into the parsing of one or more elements during the parsing of a BPMN 2.0 process.
Parser for BPMN 2.0 process models.
Continue in the broken process execution
Tree builder.
Feature enumeration type.
Class that represents a bulk action to be performed on a resource.
Class that represents a bulk action to be performed on a resource.
Use this to execute a dedicated delete statement.
Class that represents a bulk action to be performed on a resource.
Class that represents a bulk action to be performed on a resource.
Request body containing a bulk of tasks and general properties.
Request body containing a bulk of tasks and general properties.
Use this to execute a dedicated update statement.
This class implements business calendar based on internal clock
Activity implementation of the BPMN 2.0 business rule task.
Encapsulates the logic for transparently working with
ByteArrayEntity .
Encapsulates the logic for transparently working with
IdmByteArrayEntity .MyBatis TypeHandler for
ByteArrayRef.MyBatis TypeHandler for
ByteArrayRef.Concurrent (thread-safe) FIFO tree cache (using classes from
java.util.concurrent).Interface to abstract the JPA cacheable setting
Interface to express a condition whether or not a cached entity should be used in the return result of a query.
Updates caches and artifacts for a deployment and its decision (service)
Updates caches and artifacts for a deployment, its process definitions, and its process definition infos.
Updates caches and artifacts for a deployment and its event and channel definitions
Implementation of the BPMN 2.0 call activity (limited currently to calling a subprocess and not (yet) a global task).
A callback type is set on an entity that needs to 'call back' to some other entity,
typically when the entity is completed or deleted.
Send job cancelled event and delete job
Creates diagrams from case definitions.
This interface declares methods to generate case diagram
Modified the "createCaseInstance" method to conditionally call a "createCaseInstanceResponse" method with a different signature, which will conditionally return the case variables that
exist when the case instance either enters its first wait state or completes.
Modified to add a "returnVariables" flag, which determines whether the variables that exist within the process instance when the first wait state is encountered (or when the case instance
completes) should be returned or not.
[Experimental]
An interface for listener implementations that get notified when the state of a case instance changes.
Modified to add a "completed" flag, which lets the caller know if the case instance has run to completion without encountering a wait state or experiencing an error/ exception.
A builder API to create an event subscription to start an event-based case instance whenever an event with a very specific
combination of correlation values occurs.
A default implementation for the case start event subscription builder.
A builder API to delete a manually created case start event subscription which was created and registered using the
CmmnRuntimeService.createCaseInstanceStartEventSubscriptionBuilder() builder API.The implementation for a case start event subscription deletion builder.
A builder API to modify a manually created case start event subscription which was created and registered using the
CmmnRuntimeService.createCaseInstanceStartEventSubscriptionBuilder() builder API.The implementation for a case start event subscription modification builder.
The case reactivation builder is used to create all the necessary and optional information for an archived / finished case to be reactivated.
The case reactivation builder implementation storing reactivation specific information and executing the reactivation command to reactivate a historical
case instance.
Start a CMMN case with the case service task
Helper for changing the state of a process instance.
Helper for changing the state of a case instance.
Helper for changing the tenant id from active and historic instances.
Container interface to return the result of a change in a tenant id operation
An object structure representing a channel definition
Methods for working with deployments.
Specific parsing of one channel json file.
Allows programmatic querying of
ChannelDefinitions.Contains the possible properties that can be used in a
ChannelDefinitionQuery.Annotation for a test method to create and delete a deployment around a test method.
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 bpmn constructs that allow class delegation.
Helper class for Collection handlers to allow class delegation.
Constructs
ClassDelegates.Helper class for HTTP handlers to allow class delegation.
Helper class for HTTP handlers to allow class delegation.
Represents a structure encapsulated in a class
Annotation that instructs the internal flowable extensions to clean all deployments
of a test.
Removes all deployments at the end of a complete test class.
This interface provides full access to the clock
This interface provides clock reading functionality
A
DataSource implementation for test purposes that wraps another DataSource
and makes sure that the DataSource is closed when a Flowable engine gets closed.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
Builder for creating new deployments, similar to the bpmn deployment builder.
An annotation that can be used on test and lifecycle methods to inject the id of the deployment deployed via
CmmnDeployment.Allows programmatic querying of
CmmnDeployments.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.
Service to manager case instance migrations.
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.
Default implementation of a
CmmnRestResponseFactory.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.helper/convenience methods for working with collections.
Configuration settings for the command interceptor chain.
A listener that can be used to be notified of lifecycle events of the
CommandContext.The command executor for internal usage.
Command executor that passes commands to the first interceptor in the chain.
User comments that form discussions around tasks.
Common base class for implementations of
AutoDeploymentStrategy.A class holding the result from evaluating a stage or case plan model for completion.
Applies a list of transformers to the input object
Maintains an ordered composite list of child ELResolvers.
Composite implementation of
ScriptTraceListener.An annotation that can be used on test classes or as a meta annotation to use a custom configuration resource for the
FlowableExtension.An object structure representing a piece of content.
Allows programmatic querying of
ContentItems.Allows programmatic querying of
ContentItems.Service for admin and maintenance operations on the content engine.
The metadata keys that are common for each bit of content used with Flowable.
Exception indicating an operation is requested on a
ContentObject that does not exist.The metadata passed when creating a
ContentObjectStorage for reading and writing content.
Interface describing a class that is capable of resolving the content type of a resource/file based on the resource name.
Quick access methods (only usable when within a command execution) to the current
-
CommandContext,
- ProcessEngineConfigurationImpl
- TransactionContext
Note that this class is here for backwards compatibility.Special operation when executing an instance of a multi-instance.
Operation that takes the current
FlowElement set on the ExecutionEntity and executes the associated ActivityBehavior.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.A representation of a correlation key, including the
EventPayloadInstance instances
that were used to get to the key value.Throws an exception in the case when resolver is asked to get/set value.
Inspired by
RetryInterceptor, but adapted for CRDB.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.
Creates new task by
TaskBuilderProvides a parser and evaluator for unix-like cron expressions.
Can be used to pass a custom properties
HashMap to a TransactionDependentExecutionListener or to a TransactionDependentTaskListenerImplementation of the BPMN 2.0 'dataInput' and 'dataOutput'
Implementation of the BPMN 2.0 'dataInputRef' and 'dataOutputRef'
Suspended jobs are stored separately to increase the normal job query performance
DeadLetterJob entity, necessary for persistence.
Allows programmatic querying of
Jobs.This class extends
ContinueProcessOperation with the possibility to check whether execution is trying to
execute a breakpointThis
FlowableEngineAgenda schedules operations which allow debuggingContains the possible properties that can be used in a
DmnDecisionQuery.This interface declares methods to generate decision requirements diagram
Creates diagrams from decision definitions.
A utility class that hides the complexity of
DecisionEntity and Decision lookup.Default implementation of the
ActivityBehaviorFactory.Default implementation of
AutoDeploymentStrategy
that groups all Resources into a single deployment.Default implementation of
AutoDeploymentStrategy
that groups all Resources into a single deployment.Default implementation of
AutoDeploymentStrategy
that groups all Resources into a single deployment.Default implementation of
AutoDeploymentStrategy
that groups all Resources into a single deployment.Represents a canvas on which CMMN 1.1 constructs can be drawn.
Class to generate an image based the diagram interchange information in a CMMN 1.1 case.
Default implementation of a
ContentTypeResolver, resolving a limited set of well-known content types used in the engine.Default implementation of the
CorrelationKeyGenerator interface.Swallow exception for the debugger executions and add debugger breakpoint again to the suspended jobs.
Represents a canvas on which DMN 1.2 constructs can be drawn.
Class to generate an image based the diagram interchange information in a DMN 1.2 definition.
Default implementation, simply proceeding the call.
Default cache: keep everything in memory, unless a limit is set.
Default
ExpressionManager implementation that contains the logic for creating
and resolving Expression instances.For each API call (and thus
Command) being executed, a new agenda instance is created.Manager class that centralises recording of all history-related operations that are originated from inside the engine.
Default implementation of the
ListenerFactory.Represents a canvas on which BPMN 2.0 constructs can be drawn.
Class to generate an image based the diagram interchange information in a BPMN 2.0 process.
Used for
FlowElement currently not supported by the DynamicBpmnService and elements who are not parsed.The default implementation of the
VariableInstanceValueModifier interface for the Flowable Variable Service.Default implementation of the
XMLImporterFactory.Execution used in
JavaDelegates and ExecutionListeners.An
FlowableEventListener implementation which resolves an expression to a delegate FlowableEventListener instance and uses this for event notification.An
FlowableEventListener implementation which uses a classname to create a delegate FlowableEventListener instance to use for event notification.Class that provides helper operations for use in the
JavaDelegate, ActivityBehavior, ExecutionListener and TaskListener interfaces.Interceptor responsible for handling calls to 'user code'.
Provides context about the invocation of usercode and handles the actual invocation
Defines the different states of delegation that a task can be in.
This command deletes event subscriptions with a case start event and optional correlation parameter values.
This command either modifies event subscriptions with a process start event and optional correlation parameter values.
Describes methods for Queries that can perform delete operations.
Deprecated.
Deprecated.
Deprecated.
Deprecated.
Represents a deployment that is already present in the process repository.
Annotation for a test method to create and delete a deployment around a test method.
Builder for creating new deployments.
Interface for cache implementations.
An annotation that can be used on test methods, lifecycle method to inject the id of the deployment deployed via
Deployment.Allows programmatic querying of
Deployments.Contains the possible properties that can be used in a
DmnDeploymentQuery.Contains the possible properties that can be used in a
DeploymentQuery.Contains the possible properties that can be used in a
EventDefinitionQueryImpl.Destroys a scope (for example a subprocess): this means that all child executions, tasks, jobs, variables, etc within that scope are deleted.
Stores waypoints of a diagram edge.
Stores the position of a waypoint of a diagram edge.
Represents a diagram node.
Stores a two-dimensional graph layout.
Stores position and dimensions of a diagram node.
Note: only possible for event listener plan items.
This command dispatches an event within the case engine.
Command that dispatches an event.
An annotation that can be used on test classes or as a meta annotation to use a custom configuration resource for the
FlowableDmnExtension.An object structure representing an executable DMN decision
Allows programmatic querying of
DmnDecisions.Service for executing DMN decisions
Represents a deployment that is already present in the dmn repository.
Annotation for a test method to create and delete a deployment around a test method.
Annotation for a test method to create and delete a deployment around a test method.
Builder for creating new deployments.
Methods for working with deployments.
An annotation that can be used in test and lifecycle methods to inject the id of the deployment deployed via
DmnDeployment.Allows programmatic querying of
DmnDeployments.An object structure representing the execution of a decision
Allows programmatic querying of
DmnHistoricDecisionExecutions.Service providing access to the history of decision executions.
Service for admin and maintenance operations on the dmn engine.
Specific parsing of one DMN XML file, created by the
DmnParse.Service providing access to the repository of decision(services) and deployments.
Helper class for parsing ISO8601 duration format (also recurring) and computing next timer date.
A
ELResolver for dynamic bean propertiesService providing access to the repository of process definitions and deployments.
An API to manipulate running CMMN based case instances or plan items.
Default implementation for dynamically modify running CMMN based case instances and plan items.
Pojo class who can be used to check information between
DynamicBpmnService.getProcessDefinitionInfo(String) and BpmnModel.Context information for expression evaluation.
An event which indicates that an
ELContext has been created.The listener interface for receiving notification when an
ELContext is created.Represents any of the exception conditions that can arise during expression evaluation.
Enables customization of variable and property resolution behavior for EL expression evaluation.
This operations ends an execution and follows the typical BPMN rules to continue the process (if possible).
Implementations of this class can be plugged into a
AbstractEngineConfiguration.Represents a deployment that is already present in the engine repository.
Represents information about the initialization of the engine.
Interface describing a listener that gets notified when certain event occurs, related to the engine lifecycle it is attached to.
Pojo representing a variable used in REST-service which defines it's name, variable and type.
Annotation that instructs the internal flowable extensions to assert a clean DB (scans all tables to see if the DB is completely clean).
Maintains a list of all the entities in order of dependency.
An entity link is used to associate an entity with another entity.
An entity link info is used to associate a runtime or historic entity with another entity.
Service which provides access to entity links.
EntityLinksWithSameRootScopeForScopeIdAndScopeTypeMatcher<EntityImpl extends Entity & EntityLinkInfo>
Contains constants for all predefined types of entity links.
Class containing meta-data about Entity-classes.
Represents a BPMN Error definition, whereas
BpmnError represents an actual instance of an Error.This class is responsible for finding and executing error handlers for BPMN Errors.
An
FlowableEventListener that throws a error event when an event is dispatched to it.This class is responsible for finding and executing escalation handlers for BPMN Errors.
Operation that triggers conditional events for which the condition evaluate to true and continues the process, leaving that activity.
Operation that triggers conditional events for which the condition evaluate to true and continues the process, leaving that activity.
An evaluation state which is used when getting or setting a value via
Expression.Exposes twitter-like feeds for tasks and process instances.
Exposes twitter-like feeds for tasks and process instances.
An annotation that can be used on test classes or as a meta annotation to use a custom configuration resource for the
FlowableEventExtension.An object structure representing an event definition
Methods for working with deployments.
Specific parsing of one event json file.
Allows programmatic querying of
EventDefinitions.Contains the possible properties that can be used in a
EventDefinitionQuery.Represents a deployment that is already present in the event repository.
Annotation for a test method to create and delete a deployment around a test method.
Builder for creating new deployments.
An annotation that can be used on test methods, lifecycle method to inject the id of the deployment deployed via
EventDeploymentAnnotation.Allows programmatic querying of
EventDeployments.Represents a runtime event (either received or sent).
Element for defining an event listener to hook in to the global event-mechanism.
An event log entry can only be inserted (and maybe deleted).
An event log entry can only be inserted (and maybe deleted).
Simple
EventInstance serialization that maps all EventPayloadInstance's
to a json which gets transformed to a String.Simple
EventInstance serialization that maps all EventPayloadInstance's
to an XML Document which gets transformed to a String.Central registry for events that are received through external channels through a
InboundEventChannelAdapter
and then passed through as a event registry event.Service providing access to the repository of forms.
Implementation of the BPMN 2.0 event subprocess start event.
Implementation of the BPMN 2.0 event subprocess start event.
Implementation of the BPMN 2.0 event subprocess start event.
Implementation of the BPMN 2.0 event subprocess event registry start event.
Implementation of the BPMN 2.0 event subprocess message start event.
Implementation of the BPMN 2.0 event subprocess signal start event.
Implementation of the BPMN 2.0 event subprocess timer start event.
Implementation of the event subprocess variable listener start event.
Represent an event subscription for a process definition or a process instance.
Manages event subscriptions for newly-deployed process definitions and their previous versions.
Allows programmatic querying of
EventSubscriptions.A matcher for event subscriptions with a process start event and specific process definition id and optional configuration (correlation parameter values).
A matcher for event subscriptions with a case start event and specific case definition id and optional configuration (correlation parameter values).
Service which provides access to eventsubscriptions.
Validates rules that apply to all events (start event, boundary event, etc.)
Implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway as defined in the BPMN specification.
Helper for execution a decision.
A
TransactionListener that invokes an ExecutionListener.Executes a
HistoryJob directly (not through the async history executor).Operation that usually gets scheduled as last operation of handling a
Command.Command that is used by the MultiSchemaMultiTenantProcessEngineConfiguration to make sure the 'databaseSchemaUpdate' setting is applied for each tenant datasource.A
TransactionListener that invokes an ExecutionListener.Represent a 'path of execution' in a process instance.
Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Class handling invocations of ExecutionListeners
Allows programmatic querying of
Executions.Contains the possible properties that can be used in a
ExecutionQuery .Iterates over an
ExecutionTree using breadth-first searchPrints a nicely tree-looking overview of the executions.
An
AsyncExecutor that has one AsyncExecutor per tenant.Base class for the expression subclasses
ValueExpression and MethodExpression,
implementing characteristics common to both.An
CustomPropertiesResolver that evaluates a Expression when notified.An
ExecutionListener that evaluates a Expression when notified.Parses a String into a
ValueExpression or MethodExpression instance for later
evaluation.Expression factory implementation.
A profile provides a default set of language features that will define the builder's
behavior.
Class used to get hold of a
ExpressionFactory.Class responsible for handling Expression.getValue invocations
Baseclass responsible for handling invocations of Expressions
Used as an entry point for runtime evaluation of the expressions.
Expression node interface.
Class responsible for handling Expression.setValue() invocations.
Represents an external job.
EntityManager responsible for the ExternalWorkerJobEntity class.Allows programmatic querying of External Worker
Jobs.Represents a structure definition based on fields
An instance of
FieldBaseStructureDefinitionRepresents a field declaration in object form:
Expression that always returns the same value when
getValue is called.Expression that always returns the same value when
getValue is called.An
FlowableEvent related to cancel event being sent to an activity.An
FlowableActivityCancelledEvent implementation.An
FlowableEvent related to an activity within an execution.Implementation of an
FlowableActivityEvent.A date function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
A flowable implementation of
AuthenticationProvider that uses the IdmIdentityService and
UserDetailsService to check the user credentials and and load the user.The interface for a case ended event, which might be a case completed or case terminated event.
Implementation of the case completed event.
An event representing a CMMN case stage being ended either manually through termination or with an exit sentry or by completing it.
Implements a CMMN case stage ending event, holding the case and stage instances as well as the ending state of the stage.
An event representing a CMMN case stage being started.
Implements a CMMN case stage started event, holding the case and stage instances.
Runtime exception indicating the requested class was not found or an error occurred while loading the class.
JUnit Jupiter extension for the Flowable CmmnEngine and services initialization.
Convenience for CmmnEngine and services initialization in the form of a JUnit rule.
An extension that uses
SpringExtension to get the CmmnEngine from the ApplicationContext
and make it available for the FlowableCmmnExtension.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.An
FlowableEvent related to a conditional being sent to an activity.An
FlowableConditionalEvent implementation.A collection function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
A date function mapper that can be used in EL expressions
A date function mapper that can be used in EL expressions
JUnit Jupiter extension for the Flowable DmnEngine and services initialization.
Convenience for DmnEngine and services initialization in the form of a JUnit rule.
An extension that uses
SpringExtension to get the DmnEngine from the ApplicationContext
and make it available for the FlowableDmnExtension.Convenience for annotation that activates the
FlowableDmnExtension JUnit Jupiter annotation.A Helper for the Flowable
FlowableDmnExtension that can be used within the JUnit Jupiter context store
and users can use it in the tests for easy modifying of the DmnEngine time.This interface exposes methods needed to manipulate the agenda implementation.
Base class for all
FlowableEngineEvent implementations.Enumeration containing all possible types of
FlowableEvents.An
FlowableEvent related to a single entity.Base class for all
FlowableEvent implementations, related to entities.Base class for all
FlowableEvent implementations, related to entities.Base class for all
FlowableEvent implementations, represents an exception occurred, related to an entity.Base class for all
FlowableEvent implementations, represents an exception occurred, related to an entity.An
FlowableEntityEvent related to a single entity.Base class for all
FlowableEngineEntityEvent implementations, related to entities with variables.An
FlowableEvent related to an error being sent to an activity.Implementation of an
FlowableErrorEvent.An
FlowableEvent related to an escalation being sent to an activity.An
FlowableEscalationEvent implementation.Describes an event that occurred in the Flowable Engine which is dispatched to external listeners, if any.
Builder class used to create
FlowableEvent implementations.Dispatcher which allows for adding and removing
FlowableEventListener s to the Flowable Engine as well as dispatching FlowableEvent to all the listeners registered.Class capable of dispatching events.
JUnit Jupiter extension for the Flowable EventRegistryEngine and services initialization.
Base class for all
FlowableEvent implementations.Describes a class that listens for
FlowableEvents dispatched by the engine.Convenience for EventRegistryEngine and services initialization in the form of a JUnit rule.
An extension that uses
SpringExtension to get the EventRegistryEngine from the ApplicationContext
and make it available for the FlowableEventExtension.Class that allows adding and removing event listeners and dispatching events to the appropriate listeners.
A Helper for the Flowable
FlowableEventExtension that can be used within the JUnit Jupiter context store
and users can use it in the tests for easy modifying of the EventRegistryEngine time and easy access for waiting on the job executor.Enumeration containing all possible types of
FlowableEvents.Runtime exception that is the superclass of all Flowable exceptions.
Indicates the
FlowableEvent also contains information about a Throwable that occurred, triggering the event.JUnit Jupiter extension for the Flowable ProcessEngine and services initialization.
Interface for pluggable functions that can be used in the EL expressions
A date function mapper that can be used in EL expressions
Convenience class which always uses the
AsyncTaskInvoker to execute the async data.Builder class used to create
FlowableEvent implementations.Base class for all
FlowableIdmEventImpl implementations, related to entities.Builder class used to create
FlowableEvent implementations.Base class for all IDM event implementations.
Enumeration containing all possible types of Flowable IDM events.
An event related to group memberships.
Implementation of
FlowableIdmMembershipEvent.Convenience for IdmEngine and services initialization in the form of a JUnit rule.
An exception indicating that an illegal argument has been supplied in an Flowable API-call, an illegal value was configured in the engine's configuration or an illegal value has been supplied or an
illegal value is used in a process-definition.
An exception indicating that an API call could not be executed due to data being in the wrong state.
Runtime exception for all image logic.
Runtime exception for all image logic.
Runtime exception for all image logic.
Builder class used to create
FlowableEvent implementations.An
FlowableEvent related to an message being sent to an activity.An
FlowableSignalEvent implementation.An
FlowableEvent related to cancel event being sent to an activity.An
FlowableMultiInstanceActivityCancelledEvent implementation.Implementation of an
FlowableMultiInstanceActivityCompletedEvent.A
FlowableEvent related to a multi-instance activity within an execution.Implementation of an
FlowableMultiInstanceActivityEvent.Register the necessary resource hints for the Flowable SQL resources.
A collection function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
A collection function mapper that can be used in EL expressions
An exception indicating that the object that is required or actioned on does not exist.
Exception that is thrown when an optimistic locking occurs in the datastore caused by concurrent access of the same data entry.
Convenience class which always uses the
AsyncTaskInvoker to execute the async data.An
FlowableCancelledEvent implementation.Event interface for
FlowableEvent implementations related to the process engine,
exposing process engine specific functions.An
FlowableEvent related to start event being sent when a process instance is started.An
FlowableCancelledEvent implementation.Event extends default
FlowableEntityEvent with the cause of terminationAn
FlowableProcessTerminatedEvent implementation.Convenience for ProcessEngine and services initialization in the form of a JUnit rule.
Thrown by ScriptingEngines in case script evaluation failed.
An
FlowableEvent that indicates a certain sequence flow has been taken.An
FlowableEvent related to a signal being sent to an activity.An
FlowableSignalEvent implementation.An extension that uses
SpringExtension to get the ProcessEngine from the ApplicationContext
and make it available for the FlowableExtension.Register the necessary resource hints for the Flowable SQL resources.
A date function mapper that can be used in EL expressions
This exception is thrown when you try to claim a task that is already claimed by someone else.
Builder class used to create
FlowableEvent implementations.Convenience for annotation that activates the
FlowableExtension JUnit Jupiter annotation.Convenience for ProcessEngine and services initialization in the form of a JUnit base class.
A Helper for the Flowable
FlowableExtension that can be used within the JUnit Jupiter context store
and users can use it in the tests for easy modifying of the ProcessEngine time and easy access for waiting on the job executor.A date function mapper that can be used in EL expressions
A flowable implementation of
UserDetails.Provides core user information within a Flowable application.
UserDetails provider that uses the IdmIdentityService to load users.An
FlowableEvent related to a single variable.Builder class used to create
FlowableEvent implementations.Implementation of
FlowableVariableEvent.Implementation of
FlowableVariableEvent.This class is used for auto-upgrade purposes.
Exception that is thrown when the Flowable engine discovers a mismatch between the database schema version and the engine version.
A validator for stuff that is shared across all flow elements
Superclass for all 'connectable' BPMN 2.0 process elements: tasks, gateways and events.
Contains all information for displaying a form and serves as base interface for
StartFormData and TaskFormDataAn object structure representing a form
At deploy time, the engine will then parse the form definition files to an form instance of this class.
Allows programmatic querying of
FormDefinitions.Represents a deployment that is already present in the form repository.
Builder for creating new deployments.
Allows programmatic querying of
FormDeployments.Defines a form field handler.
An object structure representing a submitted form.
Allows programmatic querying of
FormInstances.Service for admin and maintenance operations on the form engine.
Represents a single property on a form.
Service providing access to the repository of forms.
Access to form data and rendered forms for starting new process instances and completing tasks.
Used to indicate the type on a
FormProperty.Default cache: keep everything in memory, without a limit.
The interface to a map between EL function names and methods.
Function node interface.
Convenience class that should be used when a Java delegation in a BPMN 2.0 process is required (for example, to call custom business logic).
Class handling invocations of FutureJavaDelegates
Super class for all gateway activity implementations.
CmmnActivityBehavior implementation for the CMMN Event Listener.Gives access to a deployed event model, e.g., an Event definition JSON file, through a stream of bytes.
Gives access to a deployed case diagram, e.g., a PNG image, through a stream of bytes.
Gives access to a deployed decision table model, e.g., a DMN XML file, through a stream of bytes.
Gives access to a deployed process diagram, e.g., a PNG image, through a stream of bytes.
Provides positions and dimensions of elements in a process diagram as provided by
GetDeploymentProcessDiagramCmd.Gives access to a deployed process model, e.g., a BPMN 2.0 XML file, through a stream of bytes.
Gives access to a deployed event model, e.g., an Event definition JSON file, through a stream of bytes.
Command for retrieving start or task form keys.
Executes a
HistoryJob directly (not through the async history executor).Created by fgroch on 15.03.17.
Represents a group, used in
IdmIdentityService.An immutable serializable implementation of
GroupAllows to programmatically query for
Groups.Contains the possible properties that can be used by the
GroupQuery.Interface indicating an element has execution-listeners
author martin.grofcik
Interface for accessing Element attributes.
Interface for accessing Element attributes.
Entities that are using revisions for optimistic locking, need to implement this interface.
A scriptable element supporting the type="script" implementation type.
An element supporting form field validation
An element supporting form field validation
Contains constants for all predefined types of hierarchies.
Represents one execution of an activity and it's stored permanent for statistics, audit and other business intelligence purposes.
Programmatic querying for
HistoricActivityInstances.Contains the possible properties which can be used in a
HistoricActivityInstanceQuery.Contains the possible properties that can be used in a
DmnHistoricDecisionExecutionQuery.Base class for all kinds of information that is related to either a
HistoricProcessInstance or a HistoricActivityInstance.Programmatic querying for
HistoricDetails.Contains the possible properties which can be used in a
HistoricDetailQuery.Historic counterpart of
EntityLink that represents the current state if any runtime link.Service which provides access to historic entity links.
A single field that was submitted in either a start form or a task form.
Historic counterpart of
IdentityLink that represents the current state if any runtime link.Service which provides access to historic variables.
Subclass of
JPAEntityListVariableType which is cacheable, unlike the super-class.Subclass of
JPAEntityVariableType which is cacheable, unlike the super-class.A single execution of a whole process definition that is stored permanently.
Allows programmatic querying of
HistoricProcessInstances.Contains the possible properties which can be used in a
HistoricProcessInstanceQueryProperty.Represents a historic task instance (waiting, finished or deleted) that is stored permanent for statistics, audit and other business intelligence purposes.
Allows programmatic querying for
HistoricTaskInstances.Interface to create and add task log entry
author martin.grofcik
Allows programmatic querying of
HistoricTaskLogEntrys;Contains the possible properties that can be used in a
HistoricTaskLogEntryQuery.Service which provides access to
HistoricTaskInstanceEntity.List that initialises binary variable values if command-context is active.
A single process variable containing the last value when its process instance has finished.
Programmatic querying for
HistoricVariableInstances.Contains the possible properties which can be used in a
HistoricVariableInstanceQuery.Service which provides access to historic variables.
Update of a process variable.
Represents one history job
History Job entity.
EntityManager responsible for the HistoryJobEntity class.History job processor which is used to process history job entities during the different history job phases.
The context used in the
HistoryJobProcessor.The job phases.
The default
HistoryJobProcessorContext implementation used in the HistoryJobProcessor.Allows programmatic querying of
HistoryJobs.Service which provides access to jobs.
Enum that contains all possible history-levels.
Service exposing information about ongoing and past process instances.
Class handling invocations of
HttpRequestHandlersClass handling invocations of
HttpResponseHandlersIdentifier node interface.
An identity link is used to associate a task with a certain identity.
An interface to handle identity link event
Service which provides access to variables.
Contains constants for all types of identity links that can be used to involve a user or group with a certain object.
generates
IdBlocks that are used to assign ids to new objects.Service for admin and maintenance operations on the idm engine.
If the behaviour of an element in a process implements this interface, it has a 'background job' functionality.
A builder to create a
InboundChannelModel instance,
which represents a channel from the 'outside world' to receive events.Builder for the filtering out inbound events.
Builder for the filtering out inbound JSON events.
Builder for the filtering out inbound XML events.
Builder for the 'key detection' part of the
InboundChannelModel.Builder for the 'key detection' part of the
InboundChannelModel, specifically for JSON events.Builder for the 'key detection' part of the
InboundChannelModel, specifically for XML events.Builder for the 'payload extraction' part of the
InboundChannelModel.Builder for the 'payload extraction' part of the
InboundChannelModel.Builder for the 'payload extraction' part of the
InboundChannelModel.Builder for the 'processing pipeline' part of the
InboundChannelModel.Builder for the 'tenant ID detection' part of the
InboundChannelModel.Builder for the 'tenant ID detection' part of the
InboundChannelModel, specifically for JSON eventsBuilder for the 'tenant ID detection' part of the
InboundChannelModel, specifically for XML eventsBuilder to create an
InboundEventChannelAdapter using JMS.Builder to create an
InboundEventChannelAdapter using Kafka.Builder to create an
InboundEventChannelAdapter using RabbitMQ.This interface must be implemented by a custom filtering bean to hook into the default inbound event processing
pipeline in order to have a very effective way to filter out events which should not be processed any further and
thus preventing expensive processing time like DB lookups and the full consumer invocation.
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based gateway as defined in the BPMN specification.
Note: only possible for event listener plan items.
A builder API to create new, dynamically injected plan items into an existing, running stage instance.
Implementation of the dynamically created and injected plan item into a running stage instance.
Base internal extension for JUnit Jupiter.
Base internal extension for JUnit Jupiter.
An extension that uses
SpringExtension to get the ProcessEngine from the ApplicationContext
and make it available for the InternalFlowableExtension.Implementation of the BPMN 2.0 'ioSpecification'
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
Implementation of the BPMN 2.0 'itemDefinition'
An instance of
ItemDefinitionImplementation of the BPMN 2.0 'itemKind'
Convenience class that should be used when a Java delegation in a BPMN 2.0 process is required (for example, to call custom business logic).
Class handling invocations of JavaDelegates
A creator of a JMS
Message from the raw event.Represents one job (timer, async job, etc.).
Represents an async job: a piece of logic that needs to be executed asynchronously.
Job entity.
EntityManager responsible for the JobEntity class.Interface for a job that can be directly executed (e.g an async job or a history job).
Contains methods that are not tied to any specific job type (async, timer, suspended or deadletter), but which are generally applicable or are about going from one type to another.
This exception is thrown when you try to execute a job that is not found (may be due to cancelActiviti="true" for instance)..
Job processor which is used to process job entities during the different job phases.
The context used in the
JobProcessor.The job phases.
The default
JobProcessorContext implementation used in the JobProcessor.Allows programmatic querying of
Jobs.Contains the possible properties that can be used in a
JobQuery.Service which provides access to jobs.
This service configuration contains all settings and instances around job execution and management.
The various types of
JobEntity subtypes, as enum.Variable type capable of storing a list of reference to JPA-entities.
Scans class and creates
EntityMetaData based on it.Variable type capable of storing reference to JPA-entities.
Defines property resolution behavior on JsonNodes.
We cannot perform a retry if we are called in an existing transaction.
Expression implementation backed by a JUEL
ValueExpression.Expression implementation backed by a JUEL
ValueExpression.ScriptEngine that used JUEL for script evaluation and compilation (JSR-223).
Factory to create
JuelScriptEngines.A
ChannelModelProcessor which is responsible for configuring Kafka Event registry integration.This interface provides a way to determine the record key that needs to be sent for a particular message
This interface provides a way to determine the partition that needs to be sent to a particular topic.
Defines property resolution behavior on instances of java.util.List.
Factory class used by the
BpmnParser and BpmnParse to instantiate the behaviour classes for TaskListener and ExecutionListener usages.A processor for converting List of a certain type into list of a different type.
Constants and functions for MDC (Mapped Diagnostic Context) logging
Service for admin and maintenance operations on the process engine.
Implementation of the BPMN 2.0 'manual task': a task that is external to the BPMS and to which there is no reference to IT systems whatsoever.
A
FlowablePlanItemFutureJavaDelegate which has a ReadOnlyDelegatePlanItemInstance as input and Map output data.A simple VariableContainer implementation with the ability to
add transient variables in addition to a VariableContainer.
Defines property resolution behavior on instances of java.util.Map.
Simplest implementation of a
Resolver backed by a Map.Implementation of the BPMN 2.0 'message'
An implicit data input association between a source and a target.
An implicit data output association between a source and a target.
An instance of a
MessageDefinitionAn
FlowableEventListener that throws a message event when an event is dispatched to it.An Expression that refers to a method on an object.
Holds information about a method that a
MethodExpression evaluated to.Thrown when a method could not be found while evaluating a
MethodExpression.This is a bridge resolver, making available any objects registered through
Mocks.register(java.lang.String, java.lang.Object) inside scripts supported by process execution.Registry for mock objects.
Represents a model that is stored in the model repository.
Allows programmatic querying of
Models.Contains the possible properties that can be used in a
ModelQuery.This command either modifies event subscriptions with a case start event and optional correlation parameter values.
This command either modifies event subscriptions with a process start event and optional correlation parameter values.
Implementation of the multi-instance functionality as described in the BPMN 2.0 spec.
A
ProcessEngineConfiguration that builds a multi tenant ProcessEngine where each tenant has its own database schema.An interface that can be implemented by a
VariableType
if wants to track changes to the data that it is saving.This class configures typeAliases in
TypeAliasRegistryThis class configures
TypeHandler in TypeHandlerRegistryAllows querying of
ActivityInstanceQuerys via native (SQL) queriesAllows querying of
Deployments via native (SQL) queriesAllows querying of
DmnDeployments via native (SQL) queriesAllows querying of
Executions via native (SQL) queriesAllows querying of
FormDeployments via native (SQL) queriesAllows querying of
Groups via native (SQL) queriesAllows querying of
HistoricActivityInstanceQuerys via native (SQL) queriesAllows querying of
HistoricDetails via native (SQL) queriesAllows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricTaskInstanceQuerys via native (SQL) queriesAllows querying of
HistoricTaskLogEntrys via native (SQL) queriesAllows querying of
HistoricVariableInstances via native (SQL) queriesAllows querying of
Models via native (SQL) queriesAllows querying of
ProcessDefinitions via native (SQL) queriesAllows querying of
ProcessInstances via native (SQL) queriesDescribes basic methods for doing native queries
Allows querying of
Tasks via native (SQL) queriesAllows querying of
Tokens via native (SQL) queriesAllows querying of
Users via native (SQL) queriesA util for detecting a GraalVM native environment.
Allows querying of
VariableInstances via native (SQL) queriesAn abstract superclass for
Command implementations that want to verify the provided task is always active (ie.An abstract superclass for
Command implementations that want to verify the provided task is always active (ie.Basic node interface.
Node pretty printer for debugging purposes.
Variable-scope only used to resolve variables when NO execution is active but expression-resolving is needed.
Implementation of the 'none start event': a start event that has no specific trigger but the programmatic one (processService.startProcessInstanceXXX()).
Arithmetic Operations as specified in chapter 1.7.
Object wrapper expression.
Implement this behavior interface if you want to hook into the end semantics of a plan item depending on its parent ending transition.
An Operation is part of an
BpmnInterface and it defines Messages that are consumed and (optionally) produced when the Operation is called.Represents an implementation of a
OperationA builder to create an
OutboundChannelModel instance.Builder for the 'event processing' pipeline which gets invoked before sending out the event.
Builder to create an
OutboundEventChannelAdapter using JMS.Builder to create an
OutboundEventChannelAdapter using Kafka.Builder to create an
OutboundEventChannelAdapter using RabbitMQ.holds the parameters of a page (partial result) for a query.
A util class that can be used to perform easy pagination (with defaults provided by Flowable).
Interface representing a paginated request object, use when paging is needed without using URL-parameters.
Implementation of the Parallel Gateway/AND gateway as defined in the BPMN 2.0 specification.
An intermediate representation of a DeploymentEntity which keeps track of all of the entity's DefinitionEntities and resources and processes associated with each
DefinitionEntity - all produced by parsing the deployment.
An intermediate representation of a DeploymentEntity which keeps track of all of the entity's ProcessDefinitionEntities and resources, and BPMN parses, models, and processes associated with each
ProcessDefinitionEntity - all produced by parsing the deployment.
An intermediate representation of a DeploymentEntity which keeps track of all of the entity's and resources.
Handcrafted top-down parser.
Provide limited support for syntax extensions.
Parse exception type
Simple implementation of the
ELContext used during parsings.Even though plan fragments don't have a runtime behavior, they still need to be stored in the
CmmnModel,
as they are needed when exporting the XML.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.
Convenience class to be used when needing to execute custom logic for a plan item by delegating to a Java class.
An interface for entities that have child
PlanItemInstances.Utility methods around a plan item container (most likely a stage or case plan model).
A plan item instance builder used to create new plan item instances with different options.
Implements the plan item instance builder API.
[Experimental]
An interface for listener implementations that get notified when the state of a plan item instance changes.
Allows to query for
PlanItemInstances.A builder that allows to execute a transition for a plan item instance from one state to another,
optionally passing variables before the transition.
Convenience class to be used when needing to execute custom logic for a plan item by delegating to a Java class.
Internal class used during criteria evaluation.
An interface that can be used to aggregate multiple variables into a single one based on an aggregation definition.
Base class for the flowable DMN test cases.
An extension which uses the
ProcessEngines.getDefaultProcessEngine() and is cached within the entire context
(i.e.An extension which uses the
IdmEngines.getDefaultIdmEngine() and is cached within the entire context
(i.e.Base class for the test cases.
Base class for the flowable test cases.
Represents a structure based on a primitive class
An instance of
PrimitiveStructureDefinitionAllows programmatic querying of
PrivilegeAn object structure representing an executable process composed of activities and transitions.
Creates diagrams from process definitions.
Default cache: keep everything in memory, unless a limit is set.
Allows programmatic querying of
ProcessDefinitions.Contains the possible properties that can be used in a
ProcessDefinitionQuery.A utility class that hides the complexity of
ProcessDefinitionEntity and Process lookup.This interface declares methods to generate process diagram
Provides positions and dimensions of elements in a process diagram as provided by
RepositoryService.getProcessDiagram(String).Provides access to all the services that expose the BPM and workflow operations.
Configuration information from which a process engine can be build.
Interface describing a listener that gets notified when certain event occurs, related to the process-engine lifecycle it is attached to.
Helper for initializing and closing process engines in server environments.
Enhances script traces with scope information for the process engine.
Represents one execution of a
ProcessDefinition.Helper for starting new ProcessInstance.
Modified the "createProcessInstance" method to conditionally call a "createProcessInstanceResponse" method with a different signature, which will conditionally return the process variables that
exist when the process instance either enters its first wait state or completes.
Modified to add a "returnVariables" flag, which determines whether the variables that exist within the process instance when the first wait state is encountered (or when the process instance
completes) should be returned or not.
A trail of data for a given process instance.
Allows to fetch the
ProcessInstanceHistoryLog for a process instance.ProcessInstanceMigrationDocumentConverter.BaseActivityMigrationMappingConverter<T extends ActivityMigrationMapping>
Allows programmatic querying of
ProcessInstances.Contains the possible properties that can be used in a
ProcessInstanceQuery.Modified to add a "completed" flag, which lets the caller know if the process instance has run to completion without encountering a wait state or experiencing an error/ exception.
A builder API to create an event subscription to start an event-based process instance whenever an event with a very specific
combination of correlation values occurs.
A default implementation for the process start event subscription builder.
A builder API to delete a manually created process start event subscription which was created and registered using the
RuntimeService#createProcessStartEventSubscriptionBuilder() builder API.The implementation for a process start event subscription deletion builder.
A builder API to modify a manually created process start event subscription which was created and registered using the
RuntimeService#createProcessStartEventSubscriptionBuilder() builder API.The implementation for a process start event subscription modification builder.
Used for passing the state to the
RuntimeInstanceStateChangeCallback instances.Service to manager process instance migrations.
Validates a process definition against the rules of the Flowable engine to be executable
Created by Pardo David on 5/12/2016.
Created by Pardo David on 5/12/2016.
Thrown when a property could not be found while evaluating a
ValueExpression or
MethodExpression.Thrown when a property could not be written to while setting the value on a
ValueExpression.Describes basic methods for querying.
Used to indicate the operator that should be used to comparing values in a query clause.
Used to indicate the operator that should be used to comparing values in a query clause.
Describes a property that can be used in a Query.
Represents a variable value used in queries.
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 reactivation listener is a very specific user event listener available on a historic case instance in order to reactivate it again.
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.
Exports a reactivation event listener and all of its attributes and elements.
The reactivation rule describes how a plan item is reactivated during phase two of case reactivation.
An
ELResolver that exposed object values in the map, under the name of the entry's key.A receive task is a wait state that waits to receive some message.
This command creates and registers a new case start event subscription based on the provided builder information.
This command creates and registers a new process start event subscription based on the provided builder information.
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.
Command that removes an event-listener from the process engine.
Command to remove the current assignee from a process instance.
Command to remove the current owner from a process instance.
Service providing access to the repository of process definitions and deployments.
Runnable that checks the
Job entities periodically for 'expired' jobs.The Resource class is used to specify resources that can be referenced by Activities.
Defines property resolution behavior on instances of java.util.ResourceBundle.
An extension that uses the configured resource to create a
ProcessEngine.An extension that uses the configured resource to create an
IdmEngine.Static methods for working with CMMN and image resource names.
Static methods for working with DMN and image resource names.
Static methods for working with BPMN and image resource names.
Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each set of Resources that share the same parent folder.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each set of Resources that share the same parent folder.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each set of Resources that share the same parent folder.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each set of Resources that share the same parent folder.
Encapsulates the logic for transparently working with
ByteArrayEntity .MyBatis TypeHandler for
ResourceRef.Generic class that represents an action to be performed on a resource.
Generic class that represents an action to be performed on a resource.
Allows enabling/disabling authentication on specific requests and allows authorisation of request after successful authentication.
Used for creating a response that represent an error that occurred.
Default implementation of a
RestResponseFactory.Helper class for building URLs based on a base URL.
Helper class for building URLs based on a base URL.
Pojo representing a variable used in REST-service which defines it's name, variable, scope and type.
Pojo representing a variable used in REST-service which defines it's name, variable, scope and type.
Intercepts
FlowableOptimisticLockingException and tries to run the same command again.Simple root property resolver implementation.
Resolves an boolean EL expression at runtime.
Resolves an EL expression value at runtime.
Handcrafted scanner.
Scan exception type
Symbol type
Request to execute a script in the scripting environment.
Builder for
ScriptEngineRequest.Scripting capable implementation of HttpRequest and HttpResponse handler.
Contains relevant information for script evaluation.
Contains relevant information for script evaluation.
Interface that could be implemented by EngineConfiguration to access ScriptingEngines.
Manages and provides access to JSR-223
ScriptEngines.Implementation of ScriptActivity CMMN 2.0 PlanItem.
Implementation of the BPMN 2.0 script task.
Created by Pardo David on 5/12/2016.
Captures meta information about a script invocation, like the start time,
the duration of the script execution, tags, whether it ended with an exception, etc.
Functional interface to enhance
ScriptTraceEnhancer.ScriptTraceContext information
with metadataAllows enhancing of
ScriptTraces with additional meta information.Listener interface notified after script invocations.
Implementation for the
<taskListener type="script" /> TaskListener extension.Implementation for the
<taskListener type="script" /> TaskListener extension.Sends an event to the event registry
ActivityBehavior used when 'delegateExpression' is used for a serviceTask.ActivityBehavior that evaluates an expression when executed.
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.
Command that changes the process definition version of an existing process instance.Command to set a new assignee on a process instance and return the previous one, if any.
Command that changes the business key of an existing process instance.Command that changes the business status of an existing process instance.Command to set a new owner on a process instance and return the previous one, if any.
Multi tenant
AsyncExecutor.Represents a bpmn signal definition
CmmnActivityBehavior implementation for the CMMN extension Signal Event Listener.Resource for notifying the engine a signal event has been received, independent of an execution.
An
FlowableEventListener that throws a signal event when an event is dispatched to it.Simple context implementation.
A simple data input association between a source and a target with assignments
Simple resolver implementation.
Represents a simple in memory structure
Interface to express a condition whether or not one specific cached entity should be used in the return result of a query.
Interface to express a condition whether or not one specific cached entity should be used in the return result of a query.
Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each resource by name.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each resource by name.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each resource by name.Implementation of
AutoDeploymentStrategy
that performs a separate deployment for each resource by name.Creates an advanced cycle business calendar manager (ACBCM).
This is an
AsyncExecutor implementation which allows invoking a custom job rejected jobs handler.Session Factory for
EntityManagerSession.
Strategy for handling jobs that were acquired but cannot be executed at this point (queue-size exceeded).
A default Spring Security
AuthenticationContext implementation that uses SecurityContextHolder and
SecurityContext to provide the information.Specific
FormData for starting a new process instance.author martin.grofcik
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.
Transforms a
String to a BigDecimalIdGenerator implementation based on the current time and the ethernet address of the machine it is running on.Represents a definition of a structure used to exchange information
An instance of
StructureDefinitionImplementation of the BPMN 2.0 subprocess (formally known as 'embedded' subprocess): a subprocess defined within another process definition.
behavior for activities that delegate to a complete separate execution of a process definition.
Suspended jobs are stored separately to increase the normal job query performance
TimerJob entity, necessary for persistence.
Allows programmatic querying of
Jobs.Contains a predefined set of states for process definitions and process instances
Helper class for suspension state
A dynamic web service client that allows to perform synchronous calls to a specific web service.
A factory for
SyncWebServiceClientStructure containing meta data (column names, column types, etc.) about a certain database table.
Data structure used for retrieving database table content.
Allows programmatic querying of
TablePages.Operation which purpose is to leave a
FlowNode.Represents one task for a human user.
Parent class for all BPMN 2.0 task types such as ServiceTask, ScriptTask, UserTask, etc.
Shared logic for resources related to Tasks.
Shared logic for resources related to Tasks.
Wraps
TaskInfo to the builder.TaskBuilder implementationThis builder is an alternative to using any of the complete methods on the TaskService.
Implementation of the shared
TaskCompletionBuilder interfaceSpecific
FormData for completing a task.Interface containing shared methods between the
TaskQuery and the HistoricTaskInstanceQuery.This is a helper class to help you work with the
TaskInfoQuery, without having to care about the awful generics.Here for backwards compatibility, prefer use the
TaskListener.Class handling invocations of
TaskListenersFunction to enrich
TaskEntity instance with additional infoAllows programmatic querying of
Tasks;Contains the possible properties that can be used in a
TaskQuery.Request body containing a task and general properties.
Request body containing a task and general properties.
Service which provides access to
Task and form related operations.Service which provides access to
Task and form related operations.Extends the default
AcquireAsyncJobsDueRunnable by setting the 'tenant' context before executing.Extends the default
AcquireTimerJobsRunnable by setting the 'tenant' context before executing.Interface for
AsyncExecutor implementations used in conjunction with the MultiSchemaMultiTenantProcessEngineConfiguration.Factory used by the
ExecutorPerTenantAsyncExecutor async executor.A
DataSource implementation that switches the currently used datasource based on the current values of the TenantInfoHolder.Extends the default
ExecuteAsyncRunnable by setting the 'tenant' context before executing.Flowable Tenant context that can be implemented in different ways to hold and store the tenant information.
Interface to be implemented when using the org.flowable.engine.impl.cfg.multitenant.MultiSchemaMultiTenantProcessEngineConfiguration and used to set/get the current user and tenant identifier.
CmmnActivityBehavior implementation for the CMMN Timer Event Listener.Stub of the common parts of a timer job.
TimerJob entity, necessary for persistence.
EntityManager responsible for TimerJobEntity instances.Allows programmatic querying of
Jobs.Service which provides access to timer jobs.
Manages timers for newly-deployed process definitions and their previous versions.
Allows programmatic querying of
TokenContains the possible properties that can be used by the
TokenQuery.A
CommandContextCloseListener that holds one TraceableObject instance that is added by MutableVariableType(s).Holder for a threadlocal stack of TransactionContext objects.
Callback interface to be notified of transaction events.
Enumeration that represents the transaction propagation behaviours supported by the command executor.
A transformation based data output association
A Transformer is responsible of transforming an object into a different object
A dummy implementation of
VariableInstance, used for storing transient variables on a VariableScope, as the VariableScope works with instances of VariableInstance
and not with raw key/values.Parsed expression, usually created by a
TreeBuilder.Tree builder interface.
Exception type thrown in build phase (scan/parse).
Tree cache interface.
A method expression is ready to be evaluated (by calling either
TreeMethodExpression.invoke(ELContext, Object[]) or TreeMethodExpression.getMethodInfo(ELContext)).Tree store class.
A value expression is ready to be evaluated (by calling either
TreeValueExpression.getType(ELContext), TreeValueExpression.getValue(ELContext), TreeValueExpression.isReadOnly(ELContext)
or TreeValueExpression.setValue(ELContext, Object).Similar to the
TriggerableActivityBehavior but with a context that allows the implementing class
to decide if the execution should be left after the trigger or notA
TransactionListener that will, typically on post-commit, trigger
the async history executor to execute the provided list of HistoryJobEntity instances.Operation that triggers a wait state and continues the process, leaving that activity.
Type Conversions as described in EL 2.1 specification (section 1.17).
Condition that resolves an UEL expression at runtime.Represents a user, used in
IdmIdentityService.Allows programmatic querying of
UserAn immutable serializable implementation of
User.CmmnActivityBehavior implementation for the CMMN User Event Listener.Form type that holds an ID of a user.
Default implementation of the
AuthenticationContext that uses a ThreadLocal that stores the PrincipalA simple user id principal that has the user id as its name.
Allows programmatic querying of
UserContains the possible properties that can be used by the
UserQuery.Created by Pardo David on 5/12/2016.
An Expression that can get or set a value.
Common interface for regular and historic variable entities.
This class encapsulates a base model object and one of its properties.
An interface that can be used to aggregate multiple variables into a single one based on an aggregation definition.
Returns the Base64 encoded value of a variable.
Checks if the value of a variable (fetched using the variableName through the variable scope) contains any of the provided values.
Checks if the value of a variable (fetched using the variableName through the variable scope) contains all of the provided values.
Compares the value of a variable (fetched using the variableName through the variable scope)
with a value on equality.
CmmnActivityBehavior implementation for the CMMN extension Variable Event Listener.Returns whether or not a variable with the given name exists when fetched through the provided variable scope.
Returns the value of a variable.
Returns the value of a variable, or a default if the value is null.
List that initialises binary variable values if command-context is active.
Generic variable class that can be reused for V6 and V5 engine.
Programmatic querying for
VariableInstances.Contains the possible properties which can be used in a
VariableInstanceQuery.This interface is the contract for modifying the values for persistent and transient variable instances.
Checks if the value of a variable (fetched using the variableName through the variable scope) is empty.
Opposite operation of the $
VariableIsEmptyExpressionFunction .The interface to a map between EL variables and the EL expressions they are associated with.
Compares the value of a variable (fetched using the variableName through the variable scope).
Interface for class that acts as a scope for variables: i.e.
Service which provides access to variables.
Wrapper class for
VariableServiceConfiguration to enable VariableValueProvider functionalityInterface describing a container for all available
VariableTypes of variables.An activity behavior that allows calling Web services
Represents a WS implementation of a
OperationRepresents a WS implementation of a
BpmnInterfaceA XML importer
Factory class used by the
WebServiceActivityBehavior to instantiate XMLImporter.