JAVA测试activiti

import org.activiti.engine.*;
import org.activiti.engine.history.HistoricIdentityLink;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.Model;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.IdentityLink;
import org.activiti.engine.task.Task;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipInputStream;

@SpringBootTest
public class TestUser {

    @Autowired
    ISysUserService sysUserService;


    @Resource
    RepositoryService repositoryService;

    @Resource
    RuntimeService runtimeService;
    @Resource
    TaskService taskService;
    @Resource
    HistoryService historyService;


 
    /**
    * @description: 部署流程
    * @author hzqq
    * @date 2025/2/14 10:36
    * @version 1.0
     */
    @Test
    public void deployProcess() {
        InputStream in = this.getClass().getResourceAsStream("/MyProcess11.zip");
        System.err.println(in);
        ZipInputStream zipInputStream = new ZipInputStream(in);
        Deployment dm = repositoryService.createDeployment()
                .name("学生请假")
                .addZipInputStream(zipInputStream)
                .deploy();

        System.err.println("id:" + dm.getId() + ",name:" + dm.getName());
    }


    /**
     * 启动流程  并设置了全局办理人，流程变量
     */
    @Test
    public void startProcess() {

        String businessKey = "UUID______xxxx-8s8s8s8j9d349r9-XXMM";
        Map<String, Object> variables = new HashMap<String, Object>();
        //设置流程变量day=3   vma_user
        variables.put("day", 55);
        variables.put("vma_user", "zzz");
        variables.put("vm_user", "xxx");
        ProcessInstance pi =
                runtimeService.startProcessInstanceByKey("myProcess",
                        businessKey, variables);

        // 将流程定义名称 作为 流程实例名称
        runtimeService.setProcessInstanceName(pi.getProcessInstanceId(), pi.getProcessDefinitionName());

        System.out.println("id:" + pi.getId() + ",流程实例ID:" + pi.getProcessInstanceId() + ",流程定义ID:" + pi.getProcessDefinitionId() + " process Name : " + pi.getProcessDefinitionName());

/*
        //通过流程实例ID获取任务对象
        Task task = taskService.createTaskQuery()
                .processInstanceId(pi.getProcessInstanceId())
                .singleResult();
        System.out.println("taskID:"+task.getId()+",name:"+task.getName());

        Map<String, Object> paramMap = new HashMap<String, Object>();
        //设置流程变量day=3   vma_user
        paramMap.put("day", 3);
        paramMap.put("vma_user", "xiao明");
        //提交任务的时候传入流程变量
        taskService.complete(task.getId(), paramMap);

        //查询任务
        task = taskService.createTaskQuery()
                .processInstanceId(pi.getProcessInstanceId())
                .singleResult();

        //如果任务对象为空,则流程执行结束
        if (task != null) {
            System.out.println("taskID:"+task.getId()+",name:"+task.getName());
        } else {
            System.out.println("任务执行完毕");
        }
        */

    }


    /**
     * 查询个人任务
     */
    @Test
    public void findTask() {
        String assignee = "zzz";
        queryUserTaskByASSIGNEE(assignee);
    }

    private void queryUserTaskByASSIGNEE(String assignee) {
        List<Task> list = taskService.createTaskQuery().taskAssignee(assignee).list();
        if (null != list && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:" + task.getId());
                System.out.println("流程实例ID:" + task.getProcessInstanceId());
                System.out.println("执行实例ID:" + task.getExecutionId());
                System.out.println("流程定义ID:" + task.getProcessDefinitionId());
                System.out.println("任务名称:" + task.getName());
                System.out.println("任务办理人:" + task.getAssignee());
                System.out.println("################################");
            }
        }
    }

    /**
     * 办理任务 <br/>
     * <b>不使用 流程变量</b> <br/>
     * <b color='red'>流程变量,在启动流程的时候，把流程变量都设置了</b>
     *
     */
    @Test
    public void completeTask() {
        String taskId = "baa2cc05-ea7c-11ef-8332-7486e20f8b57";
        // 根据任务ID去完成任务
        taskService.complete(taskId);
        // 根据任务ID去完成任务并指定流程变量
//		taskService.complete(taskId, variables);
        System.out.println("任务完成");
    }

    /**
     * 办理任务 并 带上 条件 变量 包括动态指定 下一个 任务办理人
     * <p>
     * Condition
     * ${day == 3} >= <=
     * return boolean
     * </p>
     */
    @Test
    public void completeTaskForVariable() {
        String taskId = "a77fcb5d-ea78-11ef-a987-7486e20f8b57";
        // variables   任务 执行 完成之后-------------后生效
        Map<String, Object> variables = new HashMap<>();
        variables.put("day", 66);
        variables.put("vm_user", "aBxm");
        // TODO 重要： 在此次完成过程中，数据库存在了  variables set 的 两个Key , 但是 【任务完成】 之后没有覆盖    如果是任务本地变量，complete 不会覆盖它们
        // 当前任务 执行生效
        taskService.setVariable(taskId,"day",68);
        // 根据任务ID去完成任务并指定流程变量
        taskService.complete(taskId, variables);
        System.out.println("任务完成");
    }

    @Test
    public void findTaskAssignee() {
        String assignee = "axm";
        queryUserTaskByASSIGNEE(assignee);
    }

    /**
     * @description: boss 办理任务-setVariable
     * @author hzqq
     * @date 2025/2/14 9:32
     * @version 1.0
     */
    @Test
    public void doTask() {
        String taskId = "0489ef28-ea7b-11ef-80b7-7486e20f8b57";
        taskService.setVariable(taskId, "day", "local_17778179517+----------");
        taskService.setVariable(taskId, "flag", 0);
//		taskService.
        taskService.complete(taskId);
        System.out.println("任务完成");
    }

//-----------------------------------------------------------------------------------
    /**
     * 查询任务
     */
    @Test
    public void findTaskUser() {
 //		String assignee="张三";
// 		String assignee="李四";
        String assignee="xb";
        List<Task> list = taskService.createTaskQuery().taskAssignee(assignee).list();
        if(null!=list&&list.size()>0) {
            for (Task task : list) {
                System.out.println("任务ID:"+task.getId());
                System.out.println("流程实例ID:"+task.getProcessInstanceId());
                System.out.println("执行实例ID:"+task.getExecutionId());
                System.out.println("流程定义ID:"+task.getProcessDefinitionId());
                System.out.println("任务名称:"+task.getName());
                System.out.println("任务办理人:"+task.getAssignee());
                System.out.println("################################");
            }
        }
    }


    // 查询组任务列表
    @Test
    public void findGroupList(){
        String userId = "xb";
        List<Task> list = taskService
                .createTaskQuery()//
                .taskCandidateUser(userId)//指定组任务查询
                .list();
        for(Task task:list ){
            System.out.println("id="+task.getId());
            System.out.println("name="+task.getName());
            System.out.println("assinee="+task.getAssignee());
            System.out.println("createTime ="+task.getCreateTime());
            System.out.println("executionId="+task.getExecutionId());
            System.out.println("##################################");

        }
    }



    /**
     *
     * @Title: findGroupUser
     * @Description: TODO(查询组任务成员列表)
     * @param:
     * @return: void
     * @throws
     */
    @Test
    public void findGroupUser(){
        String taskId = "35005";
        List<IdentityLink> list = taskService
                .getIdentityLinksForTask(taskId);
        //List<IdentityLink> list = processEngine.getRuntimeService()//
        //				.getIdentityLinksForProcessInstance(instanceId);
        for(IdentityLink identityLink:list ){
            System.out.println("userId="+identityLink.getUserId());
            System.out.println("taskId="+identityLink.getTaskId());
            System.out.println("piId="+identityLink.getProcessInstanceId());
            System.out.println("######################");
        }
    }


    /**
     *
     * @Title: findGroupHisUser
     * @Description: TODO 查询组任务成员历史列表
     * @param:
     * @return: void
     * @throws
     */
    @Test
    public void findGroupHistoryUser(){
        String taskId = "35005";
        List<HistoricIdentityLink> list = historyService
                .getHistoricIdentityLinksForTask(taskId);
        // List<HistoricIdentityLink> list = processEngine.getHistoryService()//
        // .getHistoricIdentityLinksForProcessInstance(processInstanceId);
        for(HistoricIdentityLink identityLink:list ){
            System.out.println("userId="+identityLink.getUserId());
            System.out.println("taskId="+identityLink.getTaskId());
            System.out.println("piId="+identityLink.getProcessInstanceId());
            System.out.println("######################");
        }
    }

    /**将组任务分配给个人任务，拾取任务*/
    //由1个人去完成任务
    @Test
    public void claim(){
        //任务ID
        String taskId = "35005";
        //分配的办理人
        String userId = "xb";
        taskService.claim(taskId, userId);
    }

    /**
     *
     * @Title: claim
     * @Description: TODO(拾取后回退)
     * @param:
     * @return: void
     * @throws
     */
    @Test
    public void claimRollback(){
        //任务ID
        String taskId = "35005";

        taskService.claim(taskId, null);
    }

    //------------------------------------------------------------------- 信息的查询


    @Test
    public void queryProcess() {
        // 创建部署信息的查询
        String deploymentId = "1";
//		Deployment deploy = repositoryService.createDeploymentQuery()
        List<Deployment> list = repositoryService.createDeploymentQuery()
                // 条件
                // .deploymentId(deploymentId) //根据部署ID去查询
                // .deploymentName(name)//根据部署名称去查询
                // .deploymentTenantId(tenantId)//根据tenantId去查询
//		.deploymentNameLike(nameLike)//根据部署名称模糊查询
                // .deploymentTenantIdLike(tenantIdLike)//根据tenantId模糊查询
                // 排序
//		.orderByDeploymentId().asc()  //根据部署ID升序
                // .orderByDeploymenTime().desc() //根据部署时间降序
                // .orderByDeploymentName()//根据部署名称升序
                // 结果集
                .list(); // 查询返回list集合
//		.listPage(firstResult, maxResults)  分页查询返回list集合
        // .singleResult(); //返回单个对象
//		.count();

        /*
         * System.out.println("部署ID:"+deploy.getId());
         * System.out.println("部署名称:"+deploy.getName());
         * System.out.println("部署时间:"+deploy.getDeploymentTime());
         */
//		System.out.println(count);
        for (Deployment deployment : list) {
            System.out.println("部署ID:" + deployment.getId());
            System.out.println("部署名称:" + deployment.getName());
            System.out.println("部署时间:" + deployment.getDeploymentTime());
            System.out.println("########################");
        }
    }

    /**
     * 查询流程定义
     */
    @Test
    public void queryProcessDefinei() {

        String processDefinitionId = "hy:1:4";
        List<ProcessDefinition> list = repositoryService.createProcessDefinitionQuery()
                .processDefinitionId(processDefinitionId).list();

        for (ProcessDefinition pe : list) {
            System.out.println(pe.getName());
            System.out.println(pe.getId());
            System.out.println(pe.getKey());
            System.out.println(pe.getResourceName());
        }
    }


    /**
     * 根据流程部署id删除流程定义
     * 删除流程定义
     */
    @Test
    public void deleteProcessDef() {
        String deploymentId = "1";
        // 根据流程部署id删除流程定义 如果当前id的流程正在执行，那么会报错
        // repositoryService.deleteDeployment(deploymentId);
        // 根据流程部署id删除删除流程定义 如果当前id的流程正在执行,会把正在执行的流程数据删除 act_ru_*和act_hi_*表里面的数据
        repositoryService.deleteDeployment(deploymentId, true);

//		repositoryService.deleteDeploymentCascade(deploymentId);==repositoryService.deleteDeployment(deploymentId, true);
        System.out.println("删除成功");
    }

//----------------------------------------------------------------------- 关于 流程变量

    @Test
    public void startProcessByKey() {

        String processDefinitionKey = "hy";
        Map<String, Object> variables = new HashMap<>();
        variables.put("请假时间", new Date());
        variables.put("请假天数", 5);
        variables.put("请假原因", "回家探亲");
        ProcessInstance proins = runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);
        System.out.println("启动成功：" + proins.getId());
        String processDefinitionId = proins.getProcessDefinitionId();

        System.out.println("启动成功：流程id：" + processDefinitionId);
    }


    @Test
    public void queryUserProcessInstance() {


        String assignee = "王五";
        List<Task> taskList = taskService.createTaskQuery().taskAssignee(assignee).list();

        taskList.stream().forEach(e -> {
            System.out.println(e.getId());
            System.out.println(e.getExecutionId());
            System.out.println(e.getAssignee());
            System.out.println(e.getName());
            System.out.println(e.getCreateTime());
        });

    }

    @Test
    public void complteProcessInstance() {
        String taskId = "22502";

        taskService.complete(taskId);
    }

    @Test
    public void queryTaskHistory() {

        String executionId = "17501";
        List<HistoricTaskInstance> hisList = historyService.createHistoricTaskInstanceQuery().executionId(executionId).list();


        hisList.forEach(e -> {
            System.out.println(e.getCreateTime());
            System.out.println("办理人" + e.getAssignee());
            System.out.println("启动时间" + e.getStartTime());
            System.out.println("结束时间" + e.getEndTime());
            System.out.println(e.getDueDate());
            System.out.println(e.getName());
            Long durationInMillis = e.getDurationInMillis();
            System.out.println(converTimeMillis(durationInMillis));
            System.out.println("--------------------------");

        });
    }

    public String converTimeMillis(Long durationInMillis) {
        if (null == durationInMillis) {
            return "-";
        }
        Long second = durationInMillis / 1000;

        double minuet = second / 60;
        return minuet + "分钟";
    }


    @Test
    public void setVariables() {

        Map<String, Object> variables = new HashMap<>();
        variables.put("请假天数", 56);
        variables.put("请假原因", "1101回家探亲");
        String executionId = "27501";
        runtimeService.setVariables(executionId, variables);
    }

    @Test
    public void setVariables2() {

        String taskId = "27507";
        //runtimeService.setVariable(executionId, "请假人", "小明");
        Map<String, Object> variables = new HashMap<>();
        variables.put("任务ID设置的", 9);//int
//		taskService.setVariable(taskId, variableName, value);
        taskService.setVariables(taskId, variables);
        System.out.println("流程变量设置成功");
    }

    @Test
    public void queryHistoryVariables() {
        String processInstanceId = "27501";
        String taskId = "27507";
        List<HistoricVariableInstance> variableList = historyService.createHistoricVariableInstanceQuery()
                .processInstanceId(processInstanceId)
//			.taskId(taskId)
                .list();

        variableList.forEach(e -> {
            System.out.println(e.getVariableName());
            System.out.println(e.getValue());
        });
    }

}