import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
/**
 * Notifies about unassigned (pooled) task.
 *
 * @param task task no notify about
 */
public void notifyPool(DelegateTask task) {
    Set<IdentityLink> links = task.getCandidates();

    links.stream()
            .filter(link -> link.getUserId() != null)
            .map(IdentityLink::getUserId)
            .forEach(username -> {
                UserDetails user = userDetailsService.loadUserById(username);
                notNull(user, () -> new MissingObject(UserDetails.class, username));

                if (hasTaskNotifyEnabled(task)) {
                    mailCenter.sendPoolAssignment(user.getEmail(), task.getExecution().getBusinessKey(),
                            task.getId(), task.getName(), task.getTaskDefinitionKey(),
                            task.getCreateTime().toInstant(),
                            task.getDueDate() != null ? task.getDueDate().toInstant() : null);
                }
            });
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
/**
 * Notifies about unassigned (pooled) task due date imminent.
 *
 * @param task task no notify about
 */
public void notifyPoolDueDate(DelegateTask task) {
    Set<IdentityLink> links = task.getCandidates();

    links.stream()
            .filter(link -> link.getUserId() != null)
            .map(IdentityLink::getUserId)
            .forEach(username -> {
                UserDetails user = userDetailsService.loadUserById(username);
                notNull(user, () -> new MissingObject(UserDetails.class, username));

                if (hasTaskNotifyEnabled(task)) {
                    mailCenter.sendPoolAssignment(user.getEmail(), task.getExecution().getBusinessKey(),
                            task.getId(), task.getName(), task.getTaskDefinitionKey(),
                            task.getCreateTime().toInstant(),
                            task.getDueDate() != null ? task.getDueDate().toInstant() : null);
                }
            });
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
protected CreateTaskCommand createCommand(DelegateTask task) {
  return CreateTaskCommand.builder()
    .taskId(task.getId())
    .taskDefinitionKey(task.getTaskDefinitionKey())
    .name(task.getName())
    .description(task.getDescription())
    .priority(task.getPriority())
    .assignee(task.getAssignee())
    .owner(task.getOwner())
    .processInstanceId(task.getProcessInstanceId())
    .caseDefinitionId(task.getCaseDefinitionId())
    .caseExecutionId(task.getCaseExecutionId())
    .createTime(task.getCreateTime())
    .dueDate(task.getDueDate())
    .formKey(getFormKey(task))
    .engineId(appName)
    .eventType(TaskListener.EVENTNAME_CREATE)
    .tenantId(task.getTenantId())
    .build();
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
protected DeleteTaskCommand createCommand(DelegateTask task) {
  return DeleteTaskCommand.builder()
    .taskId(task.getId())
    .taskDefinitionKey(task.getTaskDefinitionKey())
    .name(task.getName())
    .description(task.getDescription())
    .priority(task.getPriority())
    .assignee(task.getAssignee())
    .owner(task.getOwner())
    .processInstanceId(task.getProcessInstanceId())
    .caseDefinitionId(task.getCaseDefinitionId())
    .caseExecutionId(task.getCaseExecutionId())
    .createTime(task.getCreateTime())
    .dueDate(task.getDueDate())
    .formKey(getFormKey(task))
    .engineId(appName)
    .eventType(TaskListener.EVENTNAME_CREATE)
    .tenantId(task.getTenantId())
    .build();
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
protected CompleteTaskCommand createCommand(DelegateTask task) {
  return CompleteTaskCommand.builder()
    .taskId(task.getId())
    .taskDefinitionKey(task.getTaskDefinitionKey())
    .name(task.getName())
    .description(task.getDescription())
    .priority(task.getPriority())
    .assignee(task.getAssignee())
    .owner(task.getOwner())
    .processInstanceId(task.getProcessInstanceId())
    .caseDefinitionId(task.getCaseDefinitionId())
    .caseExecutionId(task.getCaseExecutionId())
    .createTime(task.getCreateTime())
    .dueDate(task.getDueDate())
    .formKey(getFormKey(task))
    .engineId(appName)
    .eventType(TaskListener.EVENTNAME_CREATE)
    .tenantId(task.getTenantId())
    .build();
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Test
public void creates_key_for_task() {
  ProcessDefinition processDefinition = CamundaReactorTestHelper.processDefinition();
  final DelegateTask task = mock(DelegateTask.class, RETURNS_DEEP_STUBS);

  RepositoryService repositoryService = mock(RepositoryService.class);
  when(repositoryService.getProcessDefinition(processDefinition.getId())).thenReturn(processDefinition);
  when(task.getProcessEngineServices().getRepositoryService()).thenReturn(repositoryService);

  when(task.getBpmnModelElementInstance().getElementType().getTypeName()).thenReturn("userTask");
  when(task.getProcessDefinitionId()).thenReturn("process:1:1");

  when(task.getEventName()).thenReturn("create");
  when(task.getTaskDefinitionKey()).thenReturn("task1");

  assertThat(SelectorBuilder.selector(task).key()).isEqualTo("/camunda/task/{type}/process/task1/create");
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
public void notify(DelegateTask delegateTask) {
  delegateTask.setDueDate(Process.DUE_DATE);

  delegateTask.addCandidateGroup(Process.GROUP_1);
  delegateTask.addCandidateGroups(Arrays.asList(Process.GROUP_2,Process.GROUP_3));
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Test
public void taskListenerSetsCandidateGroup() throws Exception {
  DelegateTask delegateTask = new DelegateTaskFake()
    .withTaskDefinitionKey("the_task")
    .withEventName(EVENTNAME_CREATE)
    .withVariableLocal("nextGroup", "foo");


  TaskListener taskListener = task -> {
    if (EVENTNAME_CREATE.equals(task.getEventName()) && "the_task".equals(task.getTaskDefinitionKey())) {
      task.addCandidateGroup((String) task.getVariableLocal("nextGroup"));
    }
  };

  taskListener.notify(delegateTask);

  assertThat(DelegateTaskFake.candidateGroupIds(delegateTask)).containsOnly("foo");

}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
protected BusinessProcessEvent createEvent(DelegateTask task) {
  ExecutionContext executionContext = Context.getExecutionContext();
  ProcessDefinitionEntity processDefinition = null;
  if (executionContext != null) {
    processDefinition = executionContext.getProcessDefinition();
  }

  // map type
  String eventName = task.getEventName();
  BusinessProcessEventType type = null;
  if (TaskListener.EVENTNAME_CREATE.equals(eventName)) {
    type = BusinessProcessEventType.CREATE_TASK;
  }
  else if (TaskListener.EVENTNAME_ASSIGNMENT.equals(eventName)) {
    type = BusinessProcessEventType.ASSIGN_TASK;
  }
  else if (TaskListener.EVENTNAME_COMPLETE.equals(eventName)) {
    type = BusinessProcessEventType.COMPLETE_TASK;
  }
  else if (TaskListener.EVENTNAME_DELETE.equals(eventName)) {
    type = BusinessProcessEventType.DELETE_TASK;
  }

  return new CdiBusinessProcessEvent(task, processDefinition, type, ClockUtil.getCurrentTime());
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public void notify(final DelegateTask delegateTask){
  if(delegateTask.getExecution() == null) {
    LOG.taskNotRelatedToExecution(delegateTask);
  } else {
    final DelegateExecution execution = delegateTask.getExecution();
    Callable<Void> notification = new Callable<Void>() {
      public Void call() throws Exception {
        notifyTaskListener(delegateTask);
        return null;
      }
    };
    try {
      performNotification(execution, notification);
    } catch(Exception e) {
      throw LOG.exceptionWhileNotifyingPaTaskListener(e);
    }
  }
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
protected void notifyTaskListener(DelegateTask task) throws Exception {
  ProcessApplicationReference processApp = Context.getCurrentProcessApplication();
  try {
    ProcessApplicationInterface processApplication = processApp.getProcessApplication();
    TaskListener taskListener = processApplication.getTaskListener();
    if(taskListener != null) {
      taskListener.notify(task);

    } else {
      LOG.paDoesNotProvideTaskListener(processApp.getName());

    }
  } catch (ProcessApplicationUnavailableException e) {
    // Process Application unavailable => ignore silently
    LOG.cannotInvokeListenerPaUnavailable(processApp.getName(), e);
  }
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public void notify(DelegateTask delegateTask) {
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'

  VariableScope variableScope = delegateTask.getExecution();
  if (variableScope == null) {
    variableScope = delegateTask.getCaseExecution();
  }

  Object delegate = expression.getValue(variableScope);
  applyFieldDeclaration(fieldDeclarations, delegate);

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

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
public HistoryEvent createActivityInstanceUpdateEvt(DelegateExecution execution, DelegateTask task) {
  final ExecutionEntity executionEntity = (ExecutionEntity) execution;

  // create event instance
  HistoricActivityInstanceEventEntity evt = loadActivityInstanceEventEntity(executionEntity);

  // initialize event
  initActivityInstanceEvent(evt, executionEntity, HistoryEventTypes.ACTIVITY_INSTANCE_UPDATE);

  // update task assignment
  if(task != null) {
    evt.setTaskId(task.getId());
    evt.setTaskAssignee(task.getAssignee());
  }

  return evt;
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public HistoryEvent createTaskInstanceCompleteEvt(DelegateTask task, String deleteReason) {

    // create event instance
    HistoricTaskInstanceEventEntity evt = loadTaskInstanceEvent(task);

    // initialize event
    initTaskInstanceEvent(evt, (TaskEntity) task, HistoryEventTypes.TASK_INSTANCE_COMPLETE);

    // set end time
    evt.setEndTime(ClockUtil.getCurrentTime());
    if(evt.getStartTime() != null) {
      evt.setDurationInMillis(evt.getEndTime().getTime()-evt.getStartTime().getTime());
    }

    // set delete reason
    evt.setDeleteReason(deleteReason);

    return evt;
  }
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public void notify(DelegateTask task, String event) {
  String eventCounterName = event + "EventCounter";

  Integer eventCounter = (Integer) task.getVariable(eventCounterName);

  if (eventCounter == null) {
    eventCounter = 0;
  }

  Integer counter = (Integer) task.getVariable("eventCounter");

  if (counter == null) {
    counter = 0;
  }

  task.setVariable(event, true);
  task.setVariable(eventCounterName, eventCounter + 1);
  task.setVariable("eventCounter", counter + 1);

}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public void sendMailToExecutors(DelegateTask delegateTask) {
    TechOrder techOrder = (TechOrder) delegateTask.getVariable("techorder");
    Letter letter = letterTemplateService.generateCommonForTechOrder(techOrder.getId(), delegateTask.getId());
    String assignee = delegateTask.getAssignee();
    if ((assignee != null) && (!assignee.isEmpty())) {
        mailService.sendMail(assignee, letter.getSubject(), letter.getBody());
    } else {
        Set<String> candidates = delegateTask.getCandidates().stream().map(IdentityLink::getUserId).collect(Collectors.toSet());
        for (String candidate : candidates) {
            mailService.sendMail(candidate, letter.getSubject(), letter.getBody());
        }
    }
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
public void adminResult(DelegateTask task, TechOrder techOrder) {
    if (techOrder.getWarehouse()) {
        ProcessHelper.createComment(task, historyMessages.getToAdminInWarehouse());
    } else {
        ProcessHelper.createComment(task, historyMessages.getToAdminNewOrder());
    }
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
public void notify(DelegateTask delegateTask) {
    TechOrder techOrder = (TechOrder) delegateTask.getVariable("techorder");
    String approve = (String) delegateTask.getVariable("approve");
    String commentMsg;
    if (approve.equals("no")) {
        commentMsg = String.format(historyMessages.getToStatusDeclined(), techOrder.getDeclineReason());
        this.orgStructure.getUsers().stream()
                .filter(user -> delegateTask.getAssignee().equals(user.getEmail())).findFirst()
                .ifPresent(techOrder::setDeclineUser);
    } else {
        commentMsg = historyMessages.getToStatusApproved();
    }
    ProcessHelper.createComment(delegateTask, commentMsg);
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
@Override
public void notify(DelegateTask delegateTask) {
    String processReaders = (String) delegateTask.getVariable("processReaders");
    if ((processReaders != null) && (!processReaders.isEmpty())) {
        for (String processReader : processReaders.split(",")) {
            setReader(processReader, delegateTask);
        }
    }
}
 

import org.camunda.bpm.engine.delegate.DelegateTask; //导入依赖的package包/类
private void setReader(String user, DelegateTask delegateTask) {
    if (!isUserAuthorized(user, delegateTask)) {
        DbEntityManager dbEntityManager = Context.getCommandContext().getSession(DbEntityManager.class);
        AuthorizationEntity newAuthorization = createReadAuthorization(user, delegateTask.getId());
        if (!isAuthExitInDbEntityCache(newAuthorization, dbEntityManager)) {
            dbEntityManager.insert(newAuthorization);
        }
    }
}