activiti7方法

最新推荐文章于 2024-04-03 15:54:16 发布

txSong123

最新推荐文章于 2024-04-03 15:54:16 发布

阅读量412

点赞数

本文链接：https://blog.csdn.net/jockha/article/details/119644266

版权

package com.lianchuang.activiti.modules.activiti.service.impl;

import org.activiti.bpmn.model.BpmnModel;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.history.HistoricVariableInstance;
import org.activiti.engine.repository.Deployment;
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.apache.commons.io.IOUtils;
import org.apache.tomcat.util.codec.binary.Base64;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipInputStream;

/**

TODO
@author songtianxiong
@version 1.0

@date 2021/6/30 9:37
*/
@SpringBootTest
public class activitiServiceImplTest {

/**部署流程定义（从zip）*/
@Test
public void deploymentProcessDefinition_zip(){
// 1.创建processEngine对象:默认的流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.得到repositoryService实例:仓库，用于部署
RepositoryService repositoryService = processEngine.getRepositoryService();
// 3.得到runtimeService实例：创建流程实例，完成任务，查询自己的任务
RuntimeService runtimeService = processEngine.getRuntimeService();
// 4.得到historyService实例：历史数据
HistoryService historyService = processEngine.getHistoryService();

 InputStream in = this.getClass().getClassLoader().getResourceAsStream("diagrams/helloworld.zip");
 ZipInputStream zipInputStream = new ZipInputStream(in);
 Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
         .createDeployment()//创建一个部署对象
         .name("流程定义")//添加部署的名称
         .addZipInputStream(zipInputStream)//指定zip格式的文件完成部署
         .deploy();//完成部署
 System.out.println("部署ID："+deployment.getId());//
 System.out.println("部署名称："+deployment.getName());//

}

/*部署流程定义/
@Test
public void deploymentProcessDefinition(){
// 1.创建processEngine对象:默认的流程引擎
ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// 2.得到repositoryService实例:仓库，用于部署
RepositoryService repositoryService = processEngine.getRepositoryService();
// 3.得到runtimeService实例：创建流程实例，完成任务，查询自己的任务
RuntimeService runtimeService = processEngine.getRuntimeService();
// 4.得到historyService实例：
HistoryService historyService = processEngine.getHistoryService();

 Deployment deployment = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
         .createDeployment()//创建一个部署对象
         .name("helloworld入门程序")//添加部署的名称
         .addClasspathResource("diagrams/helloworld.bpmn")//从classpath的资源中加载，一次只能加载一个文件
         .addClasspathResource("diagrams/helloworld.png")//从classpath的资源中加载，一次只能加载一个文件
         .deploy();//完成部署
 System.out.println("部署ID："+deployment.getId());//1
 System.out.println("部署名称："+deployment.getName());//helloworld入门程序

// Id的值的生成规则为:{processDefinitionKey}:{processDefinitionVersion}:{generated-id},这里的generated-id是一个自动生成的唯一的数字
}

/**启动流程实例
 当流程到达一个节点时，会在act_ru_execution表中产生1条数据
 如果当前节点时用户任务节点，这时会在acu_ru_task表中产生1条数据（任务的办理人、任务的创建时间）
 */
@Test
public void startProcessInstance(){
    //按照流程定义的id启动：myProcess:2:604
    //runtimeService.startProcessInstanceById(processDefinitionId)
    //通过流程定义的key启动流程，会启动版本更高的流程
    //流程定义的key
    String processDefinitionKey = "helloworld";
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    ProcessInstance pi = processEngine.getRuntimeService()//与正在执行的流程实例和执行对象相关的Service
            .startProcessInstanceByKey(processDefinitionKey);//使用流程定义的key启动流程实例，key对应helloworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动
    System.out.println("流程实例ID:"+pi.getId());//流程实例ID    101
    System.out.println("流程定义ID:"+pi.getProcessDefinitionId());//流程定义ID   helloworld:1:4
}

/**查询流程定义*/
@Test
public void findProcessDefinition(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    List<ProcessDefinition> list = processEngine.getRepositoryService()//与流程定义和部署对象相关的Service
            .createProcessDefinitionQuery()//创建一个流程定义的查询
            /**指定查询条件,where条件*/

// .deploymentId(deploymentId)//使用部署对象ID查询
// .processDefinitionId(processDefinitionId)//使用流程定义ID查询
// .processDefinitionKey(processDefinitionKey)//使用流程定义的key查询
// .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询

            /**排序*/
            .orderByProcessDefinitionVersion().asc()//按照版本的升序排列

// .orderByProcessDefinitionName().desc()//按照流程定义的名称降序排列

            /**返回的结果集*/
            .list();//返回一个集合列表，封装流程定义

// .singleResult();//返回惟一结果集
// .count();//返回结果集数量
// .listPage(firstResult, maxResults);//分页查询
if(list!=null && list.size()>0){
for(ProcessDefinition pd:list){
System.out.println(“流程定义ID:”+pd.getId());//流程定义的key+版本+随机生成数
System.out.println(“流程定义的名称:”+pd.getName());//对应helloworld.bpmn文件中的name属性值
System.out.println(“流程定义的key:”+pd.getKey());//对应helloworld.bpmn文件中的id属性值
System.out.println(“流程定义的版本:”+pd.getVersion());//当流程定义的key值相同的相同下，版本升级，默认1
System.out.println(“资源名称bpmn文件:”+pd.getResourceName());
System.out.println(“资源名称png文件:”+pd.getDiagramResourceName());
System.out.println(“部署对象ID：”+pd.getDeploymentId());
System.out.println("#########################################################");
}
}
}

/**删除流程定义
 *
 *
 * 说明：
 *
 *     1) 因为删除的是流程定义，而流程定义的部署是属于仓库服务的，所以应该先得到RepositoryService。
 *
 *     2)  如果该流程定义下没有正在运行的流程，则可以用普通删除。如果是有关联的信息，用级联删除。项目开发中使用级联删
 *
 * 除的情况比较多，删除操作一般只开放给超级管理员使用。
 * */
@Test
public void deleteProcessDefinition(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    //使用部署ID，完成删除
    String deploymentId = "601";
    /**
     * 不带级联的删除
     *    只能删除没有启动的流程，如果流程启动，就会抛出异常
     */

// processEngine.getRepositoryService()//
// .deleteDeployment(deploymentId);

    /**
     * 级联删除
     * 	  不管流程是否启动，都能可以删除
     */
    processEngine.getRepositoryService()//
            .deleteDeployment(deploymentId, true);
    System.out.println("删除成功！");
}


/**查询当前人的个人任务
 *
 * 说明：
 *
 * 1)    因为是任务查询，所以从processEngine中应该得到TaskService。
 * 2)    使用TaskService获取到任务查询对象TaskQuery。
 * 3)    为查询对象添加查询过滤条件，使用taskAssignee指定任务的办理者（即查询指定用户的代办任务），同时可以添加分页排序 等过滤条件。
 * 4    )调用list方法执行查询，返回办理者为指定用户的任务列表。
 * 5)    任务ID、名称、办理人、创建时间可以从act_ru_task表中查到。
 * 6)    Execution与ProcessInstance见5.6和5.7章节的介绍。在这种情况下，ProcessInstance相当于Execution。
 * 7)    如果assignee属性为部门经理，结果为空。因为现在流程只到了”填写请假申请”阶段，后面的任务还没有执行，即在数据库中没有部门经理可以办理的任务，所以查询不到。
 * 8)    一个Task节点和Execution节点是1对1的情况，在task对象中使用Execution_来表示他们之间的关系。
 * 9)    任务ID在数据库表act_ru_task中对应“ID_”列。
 *
 *
 * 附加：
 *     在activiti任务中，主要分为两大类查询任务（个人任务和组任务）：
 * 1.    确切指定了办理者的任务，这个任务将成为指定者的私有任务，即个人任务。
 * 2.    无法指定具体的某一个人来办理的任务，可以把任务分配给几个人或者一到 多个小组，让这个范围内的用户可以选择性（如有空余时间时）来办理这类任务，即组任务。
 *     先知道个人任务的查询和办理，组任务的操作后面讲
 * */
@Test
public void findMyPersonalTask(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String assignee = "王五";
    List<Task> list = processEngine.getTaskService()//与正在执行的任务管理相关的Service
            .createTaskQuery()//创建任务查询对象
            /**查询条件（where部分）*/
            .taskAssignee(assignee)//指定个人任务查询，指定办理人

// .taskCandidateUser(candidateUser)//组任务的办理人查询
// .processDefinitionId(processDefinitionId)//使用流程定义ID查询
// .processInstanceId(processInstanceId)//使用流程实例ID查询
// .executionId(executionId)//使用执行对象ID查询
/*排序/
.orderByTaskCreateTime().asc()//使用创建时间的升序排列
/*返回结果集/
// .singleResult()//返回惟一结果集
// .count()//返回结果集的数量
// .listPage(firstResult, maxResults);//分页查询
.list();//返回列表
if(list!=null && list.size()>0){
for(Task task:list){
System.out.println(“任务ID:”+task.getId());
System.out.println(“任务名称:”+task.getName());
System.out.println(“任务的创建时间:”+task.getCreateTime());
System.out.println(“任务的办理人:”+task.getAssignee());
System.out.println(“流程实例ID：”+task.getProcessInstanceId());
System.out.println(“执行对象ID:”+task.getExecutionId());
System.out.println(“流程定义ID:”+task.getProcessDefinitionId());
System.out.println("########################################################");
}
}
}

/**完成我的任务
 *
 * 说明：
 *
 * 1) 是办理任务，所以从ProcessEngine得到的是TaskService。
 * 2) 当执行完这段代码，再以员工的身份去执行查询的时候，会发现这个时候已经没有数据了，因为正在执行的任务中没有数据。
 * 3) 对于执行完的任务，activiti将从act_ru_task表中删除该任务，下一个任务会被插入进来。
 * 4) 以”部门经理”的身份进行查询，可以查到结果。因为流程执行到部门经理审批这个节点了。
 * 5) 再执行办理任务代码，执行完以后以”部门经理”身份进行查询，没有结果。
 * 6) 重复第3和4步直到流程执行完。
 *
 * */
@Test
public void completeMyPersonalTask(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    //任务ID
    String taskId = "1202";
    Map<String,Object> ver = new HashMap<>();
    ver.put("num",3);
    processEngine.getTaskService()//与正在执行的任务管理相关的Service
            .setVariable(taskId,"请假数量",ver);//设置流程变量
    processEngine.getTaskService()
            .complete(taskId);
    Map<String, Object> variables = new HashMap<String, Object>();
    variables.put("message", "重要");
    processEngine.getTaskService()//与正在执行的任务管理相关的Service
            .complete(taskId,variables);
    System.out.println("完成任务：任务ID："+taskId);
}

//----------------流程变量-----------------------------

// processEngine.getTaskService()//与正在执行的任务管理相关的Service
// .setVariable(taskId,“请假数量”,ver);//设置流程变量
// 流程变量在整个工作流中扮演很重要的作用。
// 例如：请假流程中有请假天数、请假原因等一些参数都为流程变量的范围。
// 流程变量的作用域范围是只对应一个流程实例。
// 也就是说各个流程实例的流程变量是不相互影响的。
// 流程实例结束完成以后流程变量还保存在数据库中（存放到流程变量的历史表中）。
// 说明：
// 1)流程变量的作用域就是流程实例，所以只要设置就行了，不用管在哪个阶段设置****
// 2)基本类型设置流程变量，在taskService中使用任务ID，定义流程变量的名称，设置流程变量的值。
// 3)Javabean类型设置流程变量，需要这个javabean实现了Serializable接口
// 4)设置流程变量的时候，向act_ru_variable这个表添加数据

/**获取流程变量*/
@Test
public void getVariables(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    /**与任务（正在执行）*/
    TaskService taskService = processEngine.getTaskService();
    //任务ID
    String taskId = "2104";
    /**一：获取流程变量，使用基本数据类型*/

// Integer days = (Integer) taskService.getVariable(taskId, “请假天数”);
// Date date = (Date) taskService.getVariable(taskId, “请假日期”);
// String resean = (String) taskService.getVariable(taskId, “请假原因”);
// System.out.println(“请假天数：”+days);
// System.out.println(“请假日期：”+date);
// System.out.println(“请假原因：”+resean);
/*二：获取流程变量，使用javabean类型/
// Person p = (Person)taskService.getVariable(taskId, “人员信息(添加固定版本)”);
// System.out.println(p.getId()+" "+p.getName());
}

// 说明：
// 1）流程变量的获取针对流程实例（即1个流程），每个流程实例获取的流程变量时不同的
// 2）使用基本类型获取流程变量，在taskService中使用任务ID，流程变量的名称，获取流程变量的值。
// 3）Javabean类型设置获取流程变量，除了需要这个javabean实现了Serializable接口外，还要求流程变量对象的属性不能发生变化，否则抛出异常。解决方案，固定序列化ID

/**模拟设置和获取流程变量的场景*/
public void setAndGetVariables(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();

    /**与流程实例，执行对象（正在执行）*/
    RuntimeService runtimeService = processEngine.getRuntimeService();
    /**与任务（正在执行）*/
    TaskService taskService = processEngine.getTaskService();

    /**设置流程变量*/

// runtimeService.setVariable(executionId, variableName, value)//表示使用执行对象ID，和流程变量的名称，设置流程变量的值（一次只能设置一个值）
// runtimeService.setVariables(executionId, variables)//表示使用执行对象ID，和Map集合设置流程变量，map集合的key就是流程变量的名称，map集合的value就是流程变量的值（一次设置多个值）

// taskService.setVariable(taskId, variableName, value)//表示使用任务ID，和流程变量的名称，设置流程变量的值（一次只能设置一个值）
// taskService.setVariables(taskId, variables)//表示使用任务ID，和Map集合设置流程变量，map集合的key就是流程变量的名称，map集合的value就是流程变量的值（一次设置多个值）

// runtimeService.startProcessInstanceByKey(processDefinitionKey, variables);//启动流程实例的同时，可以设置流程变量，用Map集合
// taskService.complete(taskId, variables)//完成任务的同时，设置流程变量，用Map集合

    /**获取流程变量*/

// runtimeService.getVariable(executionId, variableName);//使用执行对象ID和流程变量的名称，获取流程变量的值
// runtimeService.getVariables(executionId);//使用执行对象ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
// runtimeService.getVariables(executionId, variableNames);//使用执行对象ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中

// taskService.getVariable(taskId, variableName);//使用任务ID和流程变量的名称，获取流程变量的值
// taskService.getVariables(taskId);//使用任务ID，获取所有的流程变量，将流程变量放置到Map集合中，map集合的key就是流程变量的名称，map集合的value就是流程变量的值
// taskService.getVariables(taskId, variableNames);//使用任务ID，获取流程变量的值，通过设置流程变量的名称存放到集合中，获取指定流程变量名称的流程变量的值，值存放到Map集合中

// 说明：
// 1） RuntimeService对象可以设置流程变量和获取流程变量
// 2） TaskService对象可以设置流程变量和获取流程变量
// 3）流程实例启动的时候可以设置流程变量
// 4）任务办理完成的时候可以设置流程变量
// 5）流程变量可以通过名称/值的形式设置单个流程变量
// 6）流程变量可以通过Map集合，同时设置多个流程变量
// Map集合的key表示流程变量的名称
// Map集合的value表示流程变量的值

/**查询流程变量的历史表
 *
 * • 1：流程变量
 *             在流程执行或者任务执行的过程中，用于设置和获取变量，使用流程变量在流程传递的过程中传递业务参数。
 *     对应的表：
 *         act_ru_variable：正在执行的流程变量表
 *         act_hi_varinst：流程变量历史表
 * */
@Test
public void findHistoryProcessVariables() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    List<HistoricVariableInstance> list = processEngine.getHistoryService()//
            .createHistoricVariableInstanceQuery()//创建一个历史的流程变量查询对象
            .variableName("请假天数")
            .list();
    if (list != null && list.size() > 0) {
        for (HistoricVariableInstance hvi : list) {
            System.out.println(hvi.getId() + "   " + hvi.getProcessInstanceId() + "   " + hvi.getVariableName() + "   " + hvi.getVariableTypeName() + "    " + hvi.getValue());
            System.out.println("###############################################");
        }
    }
}


/**查询流程状态（判断流程正在执行，还是结束）
 *
 *
 *
 * 在流程执行的过程中，创建的流程实例ID在整个过程中都不会变，当流程结束后，流程实例将会在正在执行的执行对象表中（act_ru_execution）被删除
 *
 * 说明：
 * 1) 因为是查询流程实例，所以先获取runtimeService。
 * 2) 创建流程实例查询对象，设置实例ID过滤参数。
 * 3) 由于一个流程实例ID只对应一个实例，使用singleResult执行查询返回一个唯一的结果，如果结果数量大于1，则抛出异常。
 * 4) 判断指定ID的实例是否存在，如果结果为空，则代表流程结束，实例在正在执行的执行对象表中已被删除，转换成历史数据。
 *
 * */
@Test
public void isProcessEnd(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String processInstanceId = "1001";
    ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
            .createProcessInstanceQuery()//创建流程实例查询
            .processInstanceId(processInstanceId)//使用流程实例ID查询
            .singleResult();
    if(pi==null){
        System.out.println("流程已经结束");
    }
    else{
        System.out.println("流程没有结束");
    }
}

/**查询历史任务（后面讲）*/
@Test
public void findHistoryTask(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskAssignee = "张三";
    List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
            .createHistoricTaskInstanceQuery()//创建历史任务实例查询
            .taskAssignee(taskAssignee)//指定历史任务的办理人
            .list();
    if(list!=null && list.size()>0){
        for(HistoricTaskInstance hti:list){
            System.out.println(hti.getId()+"    "+hti.getName()+"    "+hti.getProcessInstanceId()+"   "+hti.getStartTime()+"   "+hti.getEndTime()+"   "+hti.getDurationInMillis());
            System.out.println("################################");
        }
    }
}


/**查询历史流程实例（后面讲）
 *
 * 查找按照某个流程定义的规则一共执行了多少次流程*/
@Test
public void findHistoryProcessInstance(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String processInstanceId = "1001";
    HistoricProcessInstance hpi = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
            .createHistoricProcessInstanceQuery()//创建历史流程实例查询
            .processInstanceId(processInstanceId)//使用流程实例ID查询
            .singleResult();
    System.out.println(hpi.getId()+"    "+hpi.getProcessDefinitionId()+"    "+hpi.getStartTime()+"    "+hpi.getEndTime()+"     "+hpi.getDurationInMillis());
}

// Execution 执行对象
// 按流程定义的规则执行一次的过程.
// 对应的表：
// act_ru_execution：正在执行的信息
// act_hi_procinst：已经执行完的历史流程实例信息
// act_hi_actinst：存放历史所有完成的活动
// ProcessInstance 流程实例
// 特指流程从开始到结束的那个最大的执行分支，一个执行的流程中，流程实例只有1个。
//
// 注意
// （1）如果是单例流程，执行对象ID就是流程实例ID
// （2）如果一个流程有分支和聚合，那么执行对象ID和流程实例ID就不相同
// （3）一个流程中，流程实例只有1个，执行对象可以存在多个。
//
// Task 任务
// 执行到某任务环节时生成的任务信息。
// 对应的表：
// act_ru_task：正在执行的任务信息
// act_hi_taskinst：已经执行完的历史任务信息

/**查询历史活动
 *
 *某一次流程的执行一共经历了多少个活动
 *
 * */
@Test
public void findHistoryActiviti() {
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String processInstanceId = "2101";
    List<HistoricActivityInstance> list = processEngine.getHistoryService()//
            .createHistoricActivityInstanceQuery()//创建历史活动实例的查询
            .processInstanceId(processInstanceId)//
            .orderByHistoricActivityInstanceStartTime().asc()//
            .list();
    if (list != null && list.size() > 0) {
        for (HistoricActivityInstance hai : list) {
            System.out.println(hai.getId() + "   " + hai.getProcessInstanceId() + "   " + hai.getActivityType() + "  " + hai.getStartTime() + "   " + hai.getEndTime() + "   " + hai.getDurationInMillis());
            System.out.println("#####################");
        }
    }
}

/**查询历史任务
 *
 *
 * 某一次流程的执行一共经历了多少个任务
 * */
@Test
public void findHistoryTask1(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String processInstanceId = "2101";
    List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的Service
            .createHistoricTaskInstanceQuery()//创建历史任务实例查询
            .processInstanceId(processInstanceId)//
            .orderByHistoricTaskInstanceStartTime().asc()
            .list();
    if(list!=null && list.size()>0){
        for(HistoricTaskInstance hti:list){
            System.out.println(hti.getId()+"    "+hti.getName()+"    "+hti.getProcessInstanceId()+"   "+hti.getStartTime()+"   "+hti.getEndTime()+"   "+hti.getDurationInMillis());
            System.out.println("################################");
        }
    }
}

// 由于数据库中保存着历史信息以及正在运行的流程实例信息，在实际项目中对已完成任务的查看频率远不及对代办和可接任
// 务的查看，所以在activiti采用分开管理，把正在运行的交给RuntimeService、TaskService管理，
// 而历史数据交给 HistoryService来管理。
// 这样做的好处在于，加快流程执行的速度，因为正在执行的流程的表中数据不会很大。

/**
 * 任务拾取，就是设置assignee的值
 */
@Test
public void taskClaim(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "97502";
    String userId = "otherUser";
    TaskService taskService = processEngine.getTaskService();
    //任务拾取，如果不是候选人可以拾取吗？可以，没限制。当userId为null时，数据表中assignee的值将被置成null，表示任务归还
    taskService.claim(taskId,userId);
}

/**
 * 任务归还，就是将assignee的值设置成null
 */
@Test
public void taskUnClaim(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "97502";
    String userId = "";
    TaskService taskService = processEngine.getTaskService();
    //任务归还，等价于taskService.claim(taskId,null);
    taskService.unclaim(taskId);
}

/**
 * 任务交接，就是重新设置assignee的值
 */
@Test
public void taskHandover(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "97502";
    String userId = "receiveTaskUser";
    TaskService taskService = processEngine.getTaskService();
    taskService.setAssignee(taskId,userId);
}

/**
 * 任务委派
 */
@Test
public void delegateTask(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "2507";
    String userId = "张三";
    String delegateUserId = "张三_delegate";
    TaskService taskService = processEngine.getTaskService();
    Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
    if (!task.getAssignee().equals(userId)){
        throw new IllegalArgumentException(userId+ "不是任务办理人，只有任务办理人才能委派任务！");
    }
    //张三 委派任务给 张三_delegate
    taskService.delegateTask(taskId,delegateUserId);
}


//被委派人解决委派任务
@Test
public void delegateTaskComplete(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String delegateUserId = "张三_delegate";
    TaskService taskService = processEngine.getTaskService();
    //查询被委托人的待办任务
    Task task = taskService.createTaskQuery().taskAssignee(delegateUserId).singleResult();
    if (task != null){
        System.out.println("查询到了任务！");
        //解决任务
        taskService.resolveTask(task.getId());
    }
}

/*任务转办*/
@Test
public void transferTask(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "2507";
    String owner = "张三";
    String userId = "张三_transfer";
    TaskService taskService = processEngine.getTaskService();
    //任务转办
    taskService.setAssignee(taskId,userId);
    //标记任务原所属人，以便统计
    taskService.setOwner(taskId,owner);

// 直接将任务转移给别人处理。
// 表现在：任务的assignee变成别人，任务的owner为null。
// 如果要查询自己转移给他人的任务，可以在转移的时候同时设置任务的owner(ru_task表和hi_task表都会被设置)，方便查询
}

//获取高亮线条和图片

// public Map findPicture(String processInstanceId){
// // 1.创建processEngine对象:默认的流程引擎
// ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
// ProcessEngineConfiguration processEngineConfiguration =processEngine.getProcessEngineConfiguration();
// // 2.得到repositoryService实例:仓库，用于部署
// RepositoryService repositoryService = processEngine.getRepositoryService();
// // 3.得到runtimeService实例：创建流程实例，完成任务，查询自己的任务
// RuntimeService runtimeService = processEngine.getRuntimeService();
// // 4.得到historyService实例：历史数据
// HistoryService historyService = processEngine.getHistoryService();
// Map map=new HashMap();
// try {
// HistoricProcessInstance historicProcessInstance=historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
//
// BpmnModel bpmnModel=repositoryService.getBpmnModel(historicProcessInstance.getProcessDefinitionId());
//
// List activityIds=new ArrayList<>();
// //判断流程实例是否已经结束
// if (historicProcessInstance.getEndTime()==null){
// //获取该流程实例的当前活动节点
// //在得到的流程图片上会以红框高亮显示
// activityIds= runtimeService.getActiveActivityIds(processInstanceId);
// }
// //获取流程图信息
// InputStream inputStream=processEngineConfiguration.getProcessEngineConfiguration().getProcessDiagramGenerator().generateDiagram(bpmnModel,“png”,activityIds);
// //转换方便页面展示图拍呢
// byte[] bytes= IOUtils.toByteArray(inputStream);
// String img=new String(Base64.encodeBase64(bytes));
// //获取该流程实例的所有历史活动，即经历的各个审批节点
// List list=historyService.createHistoricActivityInstanceQuery().processInstanceId(processInstanceId).list();
// map.put(“success”,true);
// map.put(“data”,img);
// return map;
// } catch (IOException e) {
// e.printStackTrace();
// }
// map.put(“success”,false);
// map.put(“data”,null);
// return map;
// }

//查询组任务成员列表
@Test
public void findGroupUser(){
    ProcessEngine processEngine = ProcessEngines.getDefaultProcessEngine();
    String taskId = "4408";
    List<IdentityLink> list = processEngine.getTaskService()//
            .getIdentityLinksForTask(taskId);
    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("######################");
    }
}

//-------------------------自定义sql查询器-----------------------
// List tasks = taskService.createNativeTaskQuery()
// .sql(“SELECT * FROM " + managementService.getTableName(Task.class) + " T WHERE T.NAME_ = #{taskName}”)
// .parameter(“taskName”, “gonzoTask”)
// .list();
//
// long count = taskService.createNativeTaskQuery()
// .sql(“SELECT count(*) FROM " + managementService.getTableName(Task.class) + " T1, "
// + managementService.getTableName(VariableInstanceEntity.class) + " V1 WHERE V1.TASK_ID_ = T1.ID_”)
// .count();

}

txSong123

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
activiti7方法

package com.lianchuang.activiti.modules.activiti.service.impl;import org.activiti.bpmn.model.BpmnModel;import org.activiti.engine.*;import org.activiti.engine.history.HistoricActivityInstance;import org.activiti.engine.history.HistoricProcessInstance;
复制链接

扫一扫