7、任务分配-任务分派其他人

1、个人任务分配

2、组任务分配

根据角色名称或岗位名称，分配任务到一组人身上，只要1个人处理任务，流程就会走到下一节点。
可以添加**Candicate users 候选人，使用,分割多个候选人。

2.1、多个候选人处理任务

流程执行到多个候选人的结点下时，直接使用某个候选人提交任务是不行的。需要某个候选人先认领任务后，再提交任务。

//候选人认领任务
taskService.claim(task.getId(),candidateUser);

package com.hongying.activiti;

import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricActivityInstanceQuery;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author zyk
 * @version 1.0.0
 * @ClassName CandidateUserTest
 * @Description 多个候选人执行任务
 * @createTime 2021年06月27日 19:04:00
 */
@Slf4j
public class CandidateUserTest {
    /**
     * 部署流程
     */
    @Test
    public void deployDemployment() {
        ProcessEngine defaultProcessEngine = ProcessEngines.getDefaultProcessEngine();
        RepositoryService repositoryService = defaultProcessEngine.getRepositoryService();

        Deployment deploy = repositoryService.createDeployment()
                .addClasspathResource("bpmn/Candidate.bpmn")
                .name("多个候选人任务")
                .deploy();
        log.info("请假流程部署，ID：{}", deploy.getId());
        log.info("请假流程部署，Name:{}", deploy.getName());
    }

    /**
     * 1：开启流程
     */
    @Test
    public void startProcess() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        RuntimeService runtimeService = processEngine.getRuntimeService();

        //开启流程传递变量
        ProcessInstance myLeave2 = runtimeService.startProcessInstanceByKey("candidate");
        log.info("开启新流程2：{}", myLeave2.getId());

        //打印历史信息
        printNextTask(myLeave2.getProcessDefinitionKey());
    }

    /**
     * 2：指定人提交任务。如果当前负责人是NULL，需要用候选人查找任务，找到任务后，认领任务
     */
    @Test
    public void completeProcess() {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();
        //如果是候选人，这里查询不到任务，必须先"认领"任务后，才能够查询到
        List<Task> tasks = taskService.createTaskQuery()
                .processDefinitionKey("candidate")
                .taskAssignee("gg")
                .list();
        for (Task t : tasks) {
            log.info("任务：{}-已被：{} 处理，变量：{}", t.getName(), t.getAssignee(), t.getProcessVariables());
            //完成任务
            taskService.complete(t.getId());
        }
        //待处理人
        printNextTask("candidate");

    }

    /**
     * 3、候选任务查询，认领任务后处理
     *     1：待处理列表需要用候选人查询，有任务时，需要认领。
     *     2：任务认领后就可以处理任务了
     */
    @Test
    public void queryTaskByCandidateUser() {
        String candidateUser="jl2";
        String definitionKey="candidate";

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        List<Task> candidateTasks = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                //通过候选人查，是否有任务可认领
                .taskCandidateUser(candidateUser)
                .list();

        //认领任务
        for (Task t : candidateTasks) {
            log.info("有候选人任务：{}-{}",t.getId(),t.getName());
            claimTask(t,candidateUser);
        }

        //查询个人负责任务
        List<Task> tasks2 = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .taskAssignee(candidateUser)
                .list();
        //处理任务
        for (Task t : tasks2) {
            log.info("任务：{}-已被：{} 处理", t.getName(), t.getAssignee());
            //完成任务
            taskService.complete(t.getId());
        }

        //下一个节点处理人
        printNextTask("candidate");
    }

    /**
     * 候选人 认领任务
     * @param task
     * @param candidateUser
     */
    public void claimTask(Task task,String candidateUser){
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        //候选人 认领任务
        taskService.claim(task.getId(),candidateUser);
        log.info("候选人：{}-已认领任务：{}",candidateUser,task.getId());

    }

    /**
     * 查看指定流程下的任务处理人
     *
     * @param definitionKey
     */
    private void printNextTask(String definitionKey) {
        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        List<Task> list = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .list();
        if (list == null || list.size() == 0) {
            log.info("未查询到待处理任务-{}", definitionKey);
        }

        for (Task t : list) {
            log.info("流程：{},任务：{}，将有：{} 处理", t.getProcessDefinitionId(), t.getName(), t.getAssignee());
        }

    }
}

2.2、多候选人任务使用场景，任务分派

1. 一个流程节点，可有多个人其中一个人处理。需要候选人 认领任务
2. 流程节点设置Assginee 负责人，同时又设置Candidate User时，可任务分派给候选人
3. 任务分派给候选人，Activiti没有控制这个人必须是候选人，可有事随便的一个人，需要业务程序控制

ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        //可以通过"李四"查询到待处理任务后，李四由于对业务不熟悉，可以把任务指定给其他人，李四不做处理；由其他人参花
        List<Task> tasks = taskService.createTaskQuery()
                .processDefinitionKey("candidate")
                .taskAssignee("李四")
                .list();
        for (Task t : tasks) {
            //把任务交接给"王五"，王五不是候选人也可以成功，activiti并没有做这些控制
            taskService.setAssignee(t.getId(),"王五");
            //李四不去处理任务，由王五登陆系统，审批任务
//            taskService.complete(t.getId());
        }

2.3、候选组分配-用的较多

流程中多数没有固定写死必须由哪个人负责，或者 写死几个候选人。多数情况都是通过候选组实现角色或岗位控制流程有谁处理。

1. 流程节点中 候选组 设置角色名词、或者岗位名词
2. 业务待处理列表，通过当前人角色或岗位查找是否有待认领任务，有则认领任务。然后处理任务

//通过角色名词查询获取候选组任务，认领任务后处理任务
String userRole="manager_role";

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        List<Task> candidateTasks = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .taskCandidateGroup(userRole)
                .list();

整个流程：通过角色名词查询任务后，认领任务，然后处理任务

@Test
    public void queryTaskByCandidateUser() {
        String candidateUser="jl2";
        String definitionKey="candidate";
        String userRole="manager_role";

        ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
        TaskService taskService = processEngine.getTaskService();

        List<Task> candidateTasks = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .taskCandidateGroup(userRole)
                .list();

        //认领任务
        for (Task t : candidateTasks) {
            log.info("有候选人组任务：{}-{}",t.getId(),t.getName());
            claimTask(t,candidateUser);
        }

        //查询个人负责任务
        List<Task> tasks2 = taskService.createTaskQuery()
                .processDefinitionKey(definitionKey)
                .taskAssignee(candidateUser)
                .list();
        //处理任务
        for (Task t : tasks2) {
            log.info("任务：{}-已被：{} 处理", t.getName(), t.getAssignee());
            //完成任务
            taskService.complete(t.getId());
        }

        //下一个节点处理人
        printNextTask(definitionKey);
    }