org.flowable.engine.delegate.TaskListener Java Examples

@Override
public void notify(DelegateTask delegateTask) {
    // Note: we can't cache the result of the expression, because the
    // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
    Object delegate = expression.getValue(delegateTask);
    ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate);

    if (delegate instanceof TaskListener) {
        try {
            Context.getProcessEngineConfiguration()
                    .getDelegateInterceptor()
                    .handleInvocation(new TaskListenerInvocation((TaskListener) delegate, delegateTask));
        } catch (Exception e) {
            throw new ActivitiException("Exception while invoking TaskListener: " + e.getMessage(), e);
        }
    } else {
        throw new ActivitiIllegalArgumentException("Delegate expression " + expression
                + " did not resolve to an implementation of " + TaskListener.class);
    }
}
 

public void addTaskListener(String eventName, TaskListener taskListener) {
    if (TaskListener.EVENTNAME_ALL_EVENTS.equals(eventName)) {
        // In order to prevent having to merge the "all" tasklisteners with the ones for a specific eventName,
        // every time "getTaskListener()" is called, we add the listener explicitly to the individual lists
        this.addTaskListener(TaskListener.EVENTNAME_CREATE, taskListener);
        this.addTaskListener(TaskListener.EVENTNAME_ASSIGNMENT, taskListener);
        this.addTaskListener(TaskListener.EVENTNAME_COMPLETE, taskListener);
        this.addTaskListener(TaskListener.EVENTNAME_DELETE, taskListener);

    } else {
        List<TaskListener> taskEventListeners = taskListeners.get(eventName);
        if (taskEventListeners == null) {
            taskEventListeners = new ArrayList<>();
            taskListeners.put(eventName, taskEventListeners);
        }
        taskEventListeners.add(taskListener);
    }
}
 

public void fireEvent(String taskEventName) {
    TaskDefinition taskDefinition = getTaskDefinition();
    if (taskDefinition != null) {
        List<TaskListener> taskEventListeners = getTaskDefinition().getTaskListener(taskEventName);
        if (taskEventListeners != null) {
            for (TaskListener taskListener : taskEventListeners) {
                ExecutionEntity execution = getExecution();
                if (execution != null) {
                    setEventName(taskEventName);
                }
                try {
                    Context.getProcessEngineConfiguration()
                            .getDelegateInterceptor()
                            .handleInvocation(new TaskListenerInvocation(taskListener, (DelegateTask) this));
                } catch (Exception e) {
                    throw new ActivitiException("Exception while invoking TaskListener: " + e.getMessage(), e);
                }
            }
        }
    }
}
 

private ProcessEngineConfigurationImpl getProcessEngineConfiguration() {
    ProcessEngineConfigurationImpl configuration = new org.flowable.engine.impl.cfg.StandaloneInMemProcessEngineConfiguration();
    configuration.setHistory("full").setDatabaseSchemaUpdate("true");
    configuration.setCustomDefaultBpmnParseHandlers(
            Collections.<BpmnParseHandler>singletonList(
                    new AddListenerUserTaskParseHandler(TaskListener.EVENTNAME_CREATE,
                            new UserTaskExecutionListener(USER_TASK_COMPLETED_EVENT_TYPE, USER_TASK_COMPLETED_EVENT_TYPE, listener.getSimulationEvents()))));
    configuration.setEventListeners(Collections.<FlowableEventListener>singletonList(listener));
    return configuration;
}
 

protected TaskListener getTaskListenerInstance() {
    Object delegateInstance = instantiateDelegate(className, fieldDeclarations);
    if (delegateInstance instanceof TaskListener) {
        return (TaskListener) delegateInstance;
    } else {
        throw new ActivitiIllegalArgumentException(delegateInstance.getClass().getName() + " doesn't implement " + TaskListener.class);
    }
}
 

protected TaskListener createTaskListener(BpmnParse bpmnParse, FlowableListener activitiListener, String taskId) {
    TaskListener taskListener = null;

    if (ImplementationType.IMPLEMENTATION_TYPE_CLASS.equalsIgnoreCase(activitiListener.getImplementationType())) {
        taskListener = bpmnParse.getListenerFactory().createClassDelegateTaskListener(activitiListener);
    } else if (ImplementationType.IMPLEMENTATION_TYPE_EXPRESSION.equalsIgnoreCase(activitiListener.getImplementationType())) {
        taskListener = bpmnParse.getListenerFactory().createExpressionTaskListener(activitiListener);
    } else if (ImplementationType.IMPLEMENTATION_TYPE_DELEGATEEXPRESSION.equalsIgnoreCase(activitiListener.getImplementationType())) {
        taskListener = bpmnParse.getListenerFactory().createDelegateExpressionTaskListener(activitiListener);
    }
    return taskListener;
}
 

public void deleteTask(TaskEntity task, String deleteReason, boolean cascade) {
    if (!task.isDeleted()) {
        task.fireEvent(TaskListener.EVENTNAME_DELETE);
        task.setDeleted(true);

        CommandContext commandContext = Context.getCommandContext();
        String taskId = task.getId();

        List<Task> subTasks = findTasksByParentTaskId(taskId);
        for (Task subTask : subTasks) {
            deleteTask((TaskEntity) subTask, deleteReason, cascade);
        }

        commandContext
                .getIdentityLinkEntityManager()
                .deleteIdentityLinksByTaskId(taskId);

        commandContext
                .getVariableInstanceEntityManager()
                .deleteVariableInstanceByTask(task);

        if (cascade) {
            commandContext
                    .getHistoricTaskInstanceEntityManager()
                    .deleteHistoricTaskInstanceById(taskId);
        } else {
            commandContext
                    .getHistoryManager()
                    .recordTaskEnd(taskId, deleteReason);
        }

        getDbSqlSession().delete(task);

        if (commandContext.getEventDispatcher().isEnabled()) {
            commandContext.getEventDispatcher().dispatchEvent(
                    ActivitiEventBuilder.createEntityEvent(FlowableEngineEventType.ENTITY_DELETED, task));
        }
    }
}
 

@Override
public TaskListener createExpressionTaskListener(FlowableListener activitiListener) {
    return new TaskListener() {
        @Override
        public void notify(DelegateTask delegateTask) {
            CustomListenerFactoryTest.COUNTER.addAndGet(100);
        }
    };
}
 

protected void handleAssigneeChange(CommandContext commandContext,
        ProcessEngineConfigurationImpl processEngineConfiguration) {
    processEngineConfiguration.getListenerNotificationHelper().executeTaskListeners(task, TaskListener.EVENTNAME_ASSIGNMENT);

    FlowableEventDispatcher eventDispatcher = CommandContextUtil.getEventDispatcher(commandContext);
    if (eventDispatcher != null && eventDispatcher.isEnabled()) {
        CommandContextUtil.getEventDispatcher().dispatchEvent(FlowableTaskEventBuilder.createEntityEvent(FlowableEngineEventType.TASK_ASSIGNED, task));
    }
}
 

protected static void fireAssignmentEvents(TaskEntity taskEntity) {
    CommandContextUtil.getProcessEngineConfiguration().getListenerNotificationHelper().executeTaskListeners(taskEntity, TaskListener.EVENTNAME_ASSIGNMENT);

    FlowableEventDispatcher eventDispatcher = CommandContextUtil.getEventDispatcher();
    if (eventDispatcher != null && eventDispatcher.isEnabled()) {
        eventDispatcher.dispatchEvent(
                FlowableEventBuilder.createEntityEvent(FlowableEngineEventType.TASK_ASSIGNED, taskEntity));
    }
}
 

@Override
public TaskListener createExpressionTaskListener(FlowableListener activitiListener) {
    return new TaskListener() {
        public void notify(DelegateTask delegateTask) {
            CustomListenerFactoryTest.COUNTER.addAndGet(100);
        }
    };
}
 

@SuppressWarnings("rawtypes")
public void complete(Map variablesMap, boolean localScope, boolean fireEvents) {

    if (getDelegationState() != null && getDelegationState() == DelegationState.PENDING) {
        throw new ActivitiException("A delegated task cannot be completed, but should be resolved instead.");
    }

    if (fireEvents) {
        fireEvent(TaskListener.EVENTNAME_COMPLETE);
    }

    if (Authentication.getAuthenticatedUserId() != null && processInstanceId != null) {
        getProcessInstance().involveUser(Authentication.getAuthenticatedUserId(), IdentityLinkType.PARTICIPANT);
    }

    if (Context.getProcessEngineConfiguration().getEventDispatcher().isEnabled() && fireEvents) {
        Context.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
                ActivitiEventBuilder.createEntityWithVariablesEvent(FlowableEngineEventType.TASK_COMPLETED, this, variablesMap, localScope));
    }

    Context
            .getCommandContext()
            .getTaskEntityManager()
            .deleteTask(this, TaskEntity.DELETE_REASON_COMPLETED, false);

    if (executionId != null) {
        ExecutionEntity execution = getExecution();
        execution.removeTask(this);
        execution.signal(null, null);
    }
}
 

protected static void internalDeleteTask(TaskEntity task, String deleteReason, 
        boolean cascade, boolean executeTaskDelete, boolean fireTaskListener, boolean fireEvents) {
    
    if (!task.isDeleted()) {
        
        CommandContext commandContext = CommandContextUtil.getCommandContext();
        FlowableEventDispatcher eventDispatcher = CommandContextUtil.getEventDispatcher(commandContext);
        fireEvents = fireEvents && eventDispatcher != null && eventDispatcher.isEnabled();

        if (fireTaskListener) {
            CommandContextUtil.getProcessEngineConfiguration(commandContext).getListenerNotificationHelper()
                    .executeTaskListeners(task, TaskListener.EVENTNAME_DELETE);
        }

        task.setDeleted(true);

        handleRelatedEntities(commandContext, task, deleteReason, cascade, fireTaskListener, fireEvents, eventDispatcher);
        handleTaskHistory(commandContext, task, deleteReason, cascade);

        if (executeTaskDelete) {
            executeTaskDelete(task, commandContext);
        }

        if (fireEvents) {
            fireTaskDeletedEvent(task, commandContext, eventDispatcher);
        }

    }
}
 

@Override
public TaskListener createDelegateExpressionTaskListener(FlowableListener activitiListener) {
    return new DelegateExpressionTaskListener(expressionManager.createExpression(activitiListener.getImplementation()),
            createFieldDeclarations(activitiListener.getFieldExtensions()));
}
 

protected void addDeleteListener(UserTask userTask) {
    addListenerToUserTask(userTask, TaskListener.EVENTNAME_DELETE, new CdiTaskListener(userTask.getId(), BusinessProcessEventType.DELETE_TASK));
}
 

private void addCreateListener(UserTask userTask) {
    addListenerToUserTask(userTask, TaskListener.EVENTNAME_CREATE, new CdiTaskListener(userTask.getId(), BusinessProcessEventType.CREATE_TASK));
}
 

private void addAssignListener(UserTask userTask) {
    addListenerToUserTask(userTask, TaskListener.EVENTNAME_ASSIGNMENT, new CdiTaskListener(userTask.getId(), BusinessProcessEventType.ASSIGN_TASK));
}
 

private void addCompleteListener(UserTask userTask) {
    addListenerToUserTask(userTask, TaskListener.EVENTNAME_COMPLETE, new CdiTaskListener(userTask.getId(), BusinessProcessEventType.COMPLETE_TASK));
}
 

@Override
protected void executeParse(BpmnParse bpmnParse, UserTask element) {
    TaskDefinition taskDefinition = (TaskDefinition) bpmnParse.getCurrentActivity().getProperty(UserTaskParseHandler.PROPERTY_TASK_DEFINITION);
    taskDefinition.addTaskListener(TaskListener.EVENTNAME_ASSIGNMENT, USER_TASK_ASSIGNMENT_HANDLER);
    taskDefinition.addTaskListener(TaskListener.EVENTNAME_CREATE, USER_TASK_ID_HANDLER);
}
 

public AddListenerUserTaskParseHandler(String eventName, TaskListener taskListener) {
    this.eventName = eventName;
    this.taskListener = taskListener;
}
 

@Override
public TaskListener createExpressionTaskListener(FlowableListener activitiListener) {
    return new ExpressionTaskListener(expressionManager.createExpression(activitiListener.getImplementation()));
}
 

@Override
public TaskListener createClassDelegateTaskListener(FlowableListener activitiListener) {
    return new ClassDelegate(activitiListener.getImplementation(), createFieldDeclarations(activitiListener.getFieldExtensions()));
}
 

public List<TaskListener> getTaskListener(String eventName) {
    return taskListeners.get(eventName);
}
 

public void setTaskListeners(Map<String, List<TaskListener>> taskListeners) {
    this.taskListeners = taskListeners;
}
 

public Map<String, List<TaskListener>> getTaskListeners() {
    return taskListeners;
}
 

public TaskListenerInvocation(TaskListener executionListenerInstance, DelegateTask delegateTask) {
    this.executionListenerInstance = executionListenerInstance;
    this.delegateTask = delegateTask;
}
 

public void setAssignee(String assignee, boolean dispatchAssignmentEvent, boolean dispatchUpdateEvent) {
    CommandContext commandContext = Context.getCommandContext();

    if (assignee == null && this.assignee == null) {

        // ACT-1923: even if assignee is unmodified and null, this should be stored in history.
        if (commandContext != null) {
            commandContext
                    .getHistoryManager()
                    .recordTaskAssigneeChange(id, assignee);
        }

        return;
    }
    this.assignee = assignee;

    // if there is no command context, then it means that the user is calling the
    // setAssignee outside a service method. E.g. while creating a new task.
    if (commandContext != null) {
        commandContext
                .getHistoryManager()
                .recordTaskAssigneeChange(id, assignee);

        if (assignee != null && processInstanceId != null) {
            getProcessInstance().involveUser(assignee, IdentityLinkType.PARTICIPANT);
        }

        if (!StringUtils.equals(initialAssignee, assignee)) {
            fireEvent(TaskListener.EVENTNAME_ASSIGNMENT);
            initialAssignee = assignee;
        }

        if (commandContext.getProcessEngineConfiguration().getEventDispatcher().isEnabled()) {
            if (dispatchAssignmentEvent) {
                commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
                        ActivitiEventBuilder.createEntityEvent(FlowableEngineEventType.TASK_ASSIGNED, this));
            }

            if (dispatchUpdateEvent) {
                commandContext.getProcessEngineConfiguration().getEventDispatcher().dispatchEvent(
                        ActivitiEventBuilder.createEntityEvent(FlowableEngineEventType.ENTITY_UPDATED, this));
            }
        }
    }
}
 

public abstract TaskListener createExpressionTaskListener(FlowableListener activitiListener); 

public abstract TaskListener createDelegateExpressionTaskListener(FlowableListener activitiListener); 

public abstract TaskListener createClassDelegateTaskListener(FlowableListener activitiListener);