All Classes and Interfaces
Class
Description
AbstractActivityBpmnParseHandler<T extends org.flowable.bpmn.model.FlowNode>
Denotes an 'activity' in the sense of BPMN 2.0: a parent class for all tasks, subprocess and callActivity.
AbstractBpmnParseHandler<T extends org.flowable.bpmn.model.BaseElement>
Helper class for bpmn constructs that allow class delegation.
A data association (Input or Output) between a source and a target
Abstract superclass for the common properties of all
Entity implementations.AbstractFlowNodeBpmnParseHandler<T extends org.flowable.bpmn.model.FlowNode>
Custom form types should extend this abstract class.
Abstract superclass for all operation interfaces (which are
Runnable instances), exposing some shared helper methods and member fields to subclasses.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.
A Transformer is responsible of transforming an object into a different object
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.Command that adds an event-listener to the process engine.
Implementation of the BPMN 2.0 ad-hoc subprocess.
Implementation of the BPMN 2.0 'assignment'
A
JobHandler implementation that asynchronously will end an execution asynchronously.Any type of content that is be associated with a task or with a process instance.
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.Callback interface to be notified of execution events like starting a process instance, ending an activity instance or taking a transition.
Created by Pardo David on 5/12/2016.
Transforms a
BigDecimal to a StringXML
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
Activity implementation of the BPMN 2.0 business rule task.
Updates caches and artifacts for a deployment, its process definitions, and its process definition infos.
Implementation of the BPMN 2.0 call activity (limited currently to calling a subprocess and not (yet) a global task).
Start a CMMN case with the case service task
Helper for changing the state of a process instance.
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.
Represents a structure encapsulated in a class
User comments that form discussions around tasks.
Applies a list of transformers to the input object
An annotation that can be used on test classes or as a meta annotation to use a custom configuration resource for the
FlowableExtension.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.Creates new task by
TaskBuilderCan 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'
This class extends
ContinueProcessOperation with the possibility to check whether execution is trying to
execute a breakpointThis
FlowableEngineAgenda schedules operations which allow debuggingDefault implementation of the
ActivityBehaviorFactory.Default implementation, simply proceeding the call.
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.Used for
FlowElement currently not supported by the DynamicBpmnService and elements who are not parsed.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
This command either modifies event subscriptions with a process start event and optional correlation parameter values.
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.
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
DeploymentQuery.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.
Command that dispatches an event.
Service providing access to the repository of process definitions and deployments.
Pojo class who can be used to check information between
DynamicBpmnService.getProcessDefinitionInfo(String) and BpmnModel.This operations ends an execution and follows the typical BPMN rules to continue the process (if possible).
Maintains a list of all the entities in order of dependency.
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.
Exposes twitter-like feeds for tasks and process instances.
An event log entry can only be inserted (and maybe deleted).
An event log entry can only be inserted (and maybe deleted).
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.
Manages event subscriptions for newly-deployed process definitions and their previous versions.
Implementation of the Exclusive Gateway/XOR gateway/exclusive data-based gateway as defined in the BPMN specification.
A
TransactionListener that invokes an ExecutionListener.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
CustomPropertiesResolver that evaluates a Expression when notified.An
ExecutionListener that evaluates a Expression when notified.Class responsible for handling Expression.getValue invocations
Baseclass responsible for handling invocations of Expressions
Class responsible for handling Expression.setValue() invocations.
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.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.An
FlowableEvent related to a conditional being sent to an activity.An
FlowableConditionalEvent implementation.A date function mapper that can be used in EL expressions
This interface exposes methods needed to manipulate the agenda implementation.
Base class for all
FlowableEvent implementations, related to entities.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.Builder class used to create
FlowableEvent implementations.JUnit Jupiter extension for the Flowable ProcessEngine and services initialization.
Convenience class which always uses the
AsyncTaskInvoker to execute the async data.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.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.
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.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.Implementation of
FlowableVariableEvent.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 TaskFormDataRepresents a single property on a form.
Access to form data and rendered forms for starting new process instances and completing tasks.
Used to indicate the type on a
FormProperty.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.
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.
Command for retrieving start or task form keys.
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.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.A single field that was submitted in either a start form or a task form.
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.Update of a process variable.
Service exposing information about ongoing and past process instances.
Class handling invocations of
HttpRequestHandlersClass handling invocations of
HttpResponseHandlersIf the behaviour of an element in a process implements this interface, it has a 'background job' functionality.
Implementation of the Inclusive Gateway/OR gateway/inclusive data-based gateway as defined in the BPMN specification.
Base internal extension for JUnit Jupiter.
Implementation of the BPMN 2.0 'ioSpecification'
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
Expression implementation backed by a JUEL
ValueExpression.ScriptEngine that used JUEL for script evaluation and compilation (JSR-223).
Factory to create
JuelScriptEngines.Factory class used by the
BpmnParser and BpmnParse to instantiate the behaviour classes for TaskListener and ExecutionListener usages.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.
Implementation of the BPMN 2.0 'message'
An implicit data input association between a source and a target. source is a variable in the current execution context and target is a property in the message
An implicit data output association between a source and a target. source is a property in the message and target is a variable in the current execution context
An instance of a
MessageDefinitionAn
FlowableEventListener that throws a message event when an event is dispatched to it.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 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.Allows querying of
ActivityInstanceQuerys via native (SQL) queriesAllows querying of
Deployments via native (SQL) queriesAllows querying of
Executions 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
Models via native (SQL) queriesAllows querying of
ProcessDefinitions via native (SQL) queriesAllows querying of
ProcessInstances via native (SQL) queriesAn abstract superclass for
Command implementations that want to verify the provided task is always active (ie. not suspended).Implementation of the 'none start event': a start event that has no specific trigger but the programmatic one (processService.startProcessInstanceXXX()).
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
OperationImplementation 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 ProcessDefinitionEntities and resources, and BPMN parses, models, and processes associated with each
ProcessDefinitionEntity - all produced by parsing the deployment.
An extension which uses the
ProcessEngines.getDefaultProcessEngine() and is cached within the entire context
(i.e. it would be reused by all users of the extension).Base class for the flowable test cases.
Represents a structure based on a primitive class
An instance of
PrimitiveStructureDefinitionAn 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.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.
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.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.
Created by Pardo David on 5/12/2016.
Created by Pardo David on 5/12/2016.
Used to indicate the operator that should be used to comparing values in a query clause.
A receive task is a wait state that waits to receive some message.
This command creates and registers a new process start event subscription based on the provided builder information.
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.
An extension that uses the configured resource to create a
ProcessEngine.Static methods for working with BPMN and image resource names.
Scripting capable implementation of HttpRequest and HttpResponse handler.
Implementation of the BPMN 2.0 script task.
Created by Pardo David on 5/12/2016.
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 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.
Represents a bpmn signal definition
An
FlowableEventListener that throws a signal event when an event is dispatched to it.A simple data input association between a source and a target with assignments
Represents a simple in memory structure
Specific
FormData for starting a new process instance.author martin.grofcik
Transforms a
String to a BigDecimalRepresents 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.
Helper class for suspension state
A dynamic web service client that allows to perform synchronous calls to a specific web service.
A factory for
SyncWebServiceClientOperation which purpose is to leave a
FlowNode.Parent class for all BPMN 2.0 task types such as ServiceTask, ScriptTask, UserTask, etc.
TaskBuilder implementationSpecific
FormData for completing a task.Here for backwards compatibility, prefer use the
TaskListener.Class handling invocations of
TaskListenersService which provides access to
Task and form related operations.Manages timers for newly-deployed process definitions and their previous versions.
Callback interface to be notified of transaction events.
A transformation based data output association
A Transformer is responsible of transforming an object into a different 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 notOperation that triggers a wait state and continues the process, leaving that activity.
Condition that resolves an UEL expression at runtime.Created by Pardo David on 5/12/2016.
An interface that can be used to aggregate multiple variables into a single one based on an aggregation definition.
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.