Class FlowableEventBuilder


  • public class FlowableEventBuilder
    extends Object
    Builder class used to create FlowableEvent implementations.
    Author:
    Frederik Heremans
    • Constructor Detail

      • FlowableEventBuilder

        public FlowableEventBuilder()
    • Method Detail

      • createGlobalEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEvent createGlobalEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type)
        Parameters:
        type - type of event
        Returns:
        an FlowableEvent that doesn't have it's execution context-fields filled, as the event is a global event, independent of any running execution.
      • createEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEvent createEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                              String executionId,
                                                                                              String processInstanceId,
                                                                                              String processDefinitionId)
      • createEntityEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEntityEvent createEntityEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                          Object entity)
        Parameters:
        type - type of event
        entity - the entity this event targets
        Returns:
        an FlowableEntityEvent. In case an ExecutionContext is active, the execution related event fields will be populated. If not, execution details will be retrieved from the Object if possible.
      • createProcessStartedEvent

        public static FlowableProcessStartedEvent createProcessStartedEvent​(Object entity,
                                                                            Map variables,
                                                                            boolean localScope)
        Parameters:
        entity - the entity this event targets
        variables - the variables associated with this entity
        Returns:
        an FlowableEntityEvent. In case an ExecutionContext is active, the execution related event fields will be populated. If not, execution details will be retrieved from the Object if possible.
      • createEntityWithVariablesEvent

        public static FlowableEntityWithVariablesEvent createEntityWithVariablesEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                      Object entity,
                                                                                      Map variables,
                                                                                      boolean localScope)
        Parameters:
        type - type of event
        entity - the entity this event targets
        variables - the variables associated with this entity
        Returns:
        an FlowableEntityEvent. In case an ExecutionContext is active, the execution related event fields will be populated. If not, execution details will be retrieved from the Object if possible.
      • createJobRescheduledEvent

        public static FlowableJobRescheduledEvent createJobRescheduledEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                            org.flowable.job.api.Job newJob,
                                                                            String originalJobId)
        Parameters:
        type - type of event
        newJob - the new job that was created due to the reschedule
        originalJobId - the job id of the original job that was rescheduled
        Returns:
        an FlowableEntityEvent. In case an ExecutionContext is active, the execution related event fields will be populated. If not, execution details will be retrieved from the Object if possible.
      • createSequenceFlowTakenEvent

        public static FlowableSequenceFlowTakenEvent createSequenceFlowTakenEvent​(org.flowable.engine.impl.persistence.entity.ExecutionEntity executionEntity,
                                                                                  org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                  String sequenceFlowId,
                                                                                  String sourceActivityId,
                                                                                  String sourceActivityName,
                                                                                  String sourceActivityType,
                                                                                  Object sourceActivityBehavior,
                                                                                  String targetActivityId,
                                                                                  String targetActivityName,
                                                                                  String targetActivityType,
                                                                                  Object targetActivityBehavior)
      • createEntityEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEntityEvent createEntityEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                          Object entity,
                                                                                                          String executionId,
                                                                                                          String processInstanceId,
                                                                                                          String processDefinitionId)
        Parameters:
        type - type of event
        entity - the entity this event targets
        Returns:
        an FlowableEntityEvent
      • createEntityExceptionEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEntityEvent createEntityExceptionEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                                   Object entity,
                                                                                                                   Throwable cause)
        Parameters:
        type - type of event
        entity - the entity this event targets
        cause - the cause of the event
        Returns:
        an FlowableEntityEvent that is also instance of FlowableExceptionEvent. In case an ExecutionContext is active, the execution related event fields will be populated.
      • createEntityExceptionEvent

        public static org.flowable.common.engine.api.delegate.event.FlowableEntityEvent createEntityExceptionEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                                   Object entity,
                                                                                                                   Throwable cause,
                                                                                                                   String executionId,
                                                                                                                   String processInstanceId,
                                                                                                                   String processDefinitionId)
        Parameters:
        type - type of event
        entity - the entity this event targets
        cause - the cause of the event
        Returns:
        an FlowableEntityEvent that is also instance of FlowableExceptionEvent.
      • createActivityEvent

        public static FlowableActivityEvent createActivityEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                String activityId,
                                                                String activityName,
                                                                String executionId,
                                                                String processInstanceId,
                                                                String processDefinitionId,
                                                                org.flowable.bpmn.model.FlowElement flowElement)
      • createMultiInstanceActivityEvent

        public static FlowableMultiInstanceActivityEvent createMultiInstanceActivityEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                          String activityId,
                                                                                          String activityName,
                                                                                          String executionId,
                                                                                          String processInstanceId,
                                                                                          String processDefinitionId,
                                                                                          org.flowable.bpmn.model.FlowElement flowElement)
      • createMultiInstanceActivityCompletedEvent

        public static FlowableMultiInstanceActivityCompletedEvent createMultiInstanceActivityCompletedEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                            int numberOfInstances,
                                                                                                            int numberOfActiveInstances,
                                                                                                            int numberOfCompletedInstances,
                                                                                                            String activityId,
                                                                                                            String activityName,
                                                                                                            String executionId,
                                                                                                            String processInstanceId,
                                                                                                            String processDefinitionId,
                                                                                                            org.flowable.bpmn.model.FlowElement flowElement)
      • parseActivityType

        protected static String parseActivityType​(org.flowable.bpmn.model.FlowNode flowNode)
      • createTerminateEvent

        public static FlowableProcessTerminatedEvent createTerminateEvent​(org.flowable.engine.impl.persistence.entity.ExecutionEntity execution,
                                                                          Object cause)
      • createSignalEvent

        public static FlowableSignalEvent createSignalEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                            String activityId,
                                                            String signalName,
                                                            Object signalData,
                                                            String executionId,
                                                            String processInstanceId,
                                                            String processDefinitionId)
      • createMessageEvent

        public static FlowableMessageEvent createMessageEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                              String activityId,
                                                              String messageName,
                                                              Object payload,
                                                              String executionId,
                                                              String processInstanceId,
                                                              String processDefinitionId)
      • createConditionalEvent

        public static FlowableConditionalEvent createConditionalEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                      String activityId,
                                                                      String conditionExpression,
                                                                      String executionId,
                                                                      String processInstanceId,
                                                                      String processDefinitionId)
      • createEscalationEvent

        public static FlowableEscalationEvent createEscalationEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                    String activityId,
                                                                    String escalationCode,
                                                                    String escalationName,
                                                                    String executionId,
                                                                    String processInstanceId,
                                                                    String processDefinitionId)
      • createErrorEvent

        public static FlowableErrorEvent createErrorEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                          String activityId,
                                                          String errorId,
                                                          String errorCode,
                                                          String executionId,
                                                          String processInstanceId,
                                                          String processDefinitionId)
      • createVariableEvent

        public static org.flowable.variable.api.event.FlowableVariableEvent createVariableEvent​(org.flowable.common.engine.api.delegate.event.FlowableEngineEventType type,
                                                                                                String variableName,
                                                                                                Object variableValue,
                                                                                                org.flowable.variable.api.types.VariableType variableType,
                                                                                                String taskId,
                                                                                                String executionId,
                                                                                                String processInstanceId,
                                                                                                String processDefinitionId)
      • populateEventWithCurrentContext

        protected static void populateEventWithCurrentContext​(org.flowable.common.engine.impl.event.FlowableEngineEventImpl event)