cativiti工具类

工具类代码

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.eam.common.core.page.TableDataInfo;
import com.eam.common.exception.ServiceException;
import com.eam.common.utils.ProcessBusiness;
import com.eam.common.utils.spring.SpringUtils;
import com.eam.mes.group.domain.SysUserGroup;
import com.eam.mes.group.service.ISysUserGroupService;
import com.eam.workflow.domain.DeploymentImplClass;
import com.eam.workflow.domain.UserTaskVo;
import com.eam.workflow.domain.WorkflowTask;
import org.activiti.bpmn.model.BpmnModel;
import org.activiti.bpmn.model.FlowElement;
import org.activiti.bpmn.model.UserTask;
import org.activiti.engine.*;
import org.activiti.engine.history.HistoricTaskInstance;
import org.activiti.engine.repository.Deployment;
import org.activiti.engine.repository.ProcessDefinition;
import org.activiti.engine.runtime.ProcessInstance;
import org.activiti.engine.task.Task;
import org.activiti.engine.task.TaskQuery;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;
import java.util.stream.Collectors;

import static com.eam.common.utils.SecurityUtils.getUserId;

public class ProcessUtil {
    private static final String START_EVENT_COLOR = "发起申请";
    private static final String BUSINESS_TABLE = "BUSINESS_TABLE";
    private static final String BUSINESS_PRIMARY_KEY = "BUSINESS_PRIMARY_KEY";

    private static final String COMMENTS_DEFAULT_VALUE = "同意";
    private static final String COMMENTS_NO_PASS_VALUE = "不同意";
    private static final String CONDITION_VARIABLE = "CONDITION_VARIABLE";
    private static final String PASS = "PASS";
    private static final String NO_PASS = "NO_PASS";
    protected static final Logger logger = LoggerFactory.getLogger(ProcessUtil.class);

    /**
     *
     * @param processBusiness 流程ID挂载,需要实现此接口,新增字段流程实例ProcessInstanceId以及BusinessId业务id
     * @param instanceByKey 流程实例钥匙
     * @param nextTaskAssigneeLongId 下一节点办理人
     * @return
     */
    public static Map<String,Object> startProcess(ProcessBusiness processBusiness,String instanceByKey,String nextTaskAssigneeLongId){
        TaskService taskService = SpringUtils.getBean(TaskService.class);
        RuntimeService runtimeService = SpringUtils.getBean(RuntimeService.class);
        TaskQuery taskQuery = taskService.createTaskQuery();
        //加载一个测试流程
        ProcessInstance instance = runtimeService.startProcessInstanceByKey(instanceByKey, processBusiness.getBusinessId(),new HashMap<String,Object>(){{
            put(BUSINESS_TABLE,instanceByKey);
            put(BUSINESS_PRIMARY_KEY,processBusiness.getBusinessId());
        }});
        //获取当前任务节点
        processBusiness.setProcessInstanceId(instance.getProcessInstanceId());
        processBusiness.setBusinessType(instanceByKey);
        processBusiness.setBusinessId(processBusiness.getBusinessId());
        processBusiness.updateById();
        Task task = taskQuery.processInstanceId(instance.getId()).singleResult();
        //设置办理人
        taskService.setAssignee(task.getId(), String.valueOf(getUserId()));
        //设置审批意见
        taskService.addComment(task.getId(),task.getProcessInstanceId(),START_EVENT_COLOR);
        taskService.complete(task.getId());
        // 查询下一个用户任务节点的任务
        String executionId = task.getExecutionId();
        Task nextTask = taskQuery.executionId(executionId).singleResult();
        if (nextTask != null && StringUtils.isNotBlank(nextTaskAssigneeLongId)) {
            // 设置下一节点的办理人
            taskService.setAssignee(nextTask.getId(), nextTaskAssigneeLongId);
            logger.info("下一节点任务办理人设置为{}.",nextTaskAssigneeLongId);
        }
        return new HashMap<String,Object>(){{
            put("instanceId",instance.getId());
            put("workflowTaskId",task.getId());
        }};
    }


    /**
     * 根据用户id查询待办列表
     * @param userId
     * @return
     */
    public static List<WorkflowTask> selectWait(Long userId){
        TaskService bean = SpringUtils.getBean(TaskService.class);
        List<Task> list = bean.createTaskQuery()
                .taskCandidateOrAssigned(String.valueOf(userId))
                .orderByTaskCreateTime()
                .desc()
                .list();
        ISysUserGroupService groupService = SpringUtils.getBean(ISysUserGroupService.class);
        List<SysUserGroup> groupList = groupService.list(Wrappers.<SysUserGroup>lambdaQuery().eq(SysUserGroup::getUserId, userId));
        if (!groupList.isEmpty()) {
            List<String> collect = groupList.stream().map(SysUserGroup::getGroupId).distinct().map(String::valueOf).collect(Collectors.toList());
            if (!collect.isEmpty()) {
                List<Task> tasks = bean.createTaskQuery()
                        .taskCandidateGroupIn(collect)
                        .orderByTaskCreateTime()
                        .desc()
                        .list();
                if (!tasks.isEmpty()) {
                    list.addAll(tasks);
                    list = list.stream().distinct().collect(Collectors.toList());
                }
            }
        }
        if (CollectionUtils.isNotEmpty(list)) {
            return list.stream().map(WorkflowTask::new).collect(Collectors.toList());
        }
        return new ArrayList<>();
    }



    /**
     * 根据用户id查询已办列表
     * @param userId
     * @return
     */
    public static List<WorkflowTask> selectDone(Long userId){
        HistoryService  bean = SpringUtils.getBean(HistoryService.class);
        List<HistoricTaskInstance> list = bean.createHistoricTaskInstanceQuery()
                .taskAssignee(String.valueOf(userId)).finished()
                .orderByTaskCreateTime()
                .desc()
                .list();
        if (CollectionUtils.isNotEmpty(list)) {
            return list.stream().map(WorkflowTask::new).collect(Collectors.toList());
        }
        return new ArrayList<>();
    }

    private static List<WorkflowTask> selectDoneNoFinished(Long userId){
        HistoryService  bean = SpringUtils.getBean(HistoryService.class);
        List<HistoricTaskInstance> list = bean.createHistoricTaskInstanceQuery()
                .taskAssignee(String.valueOf(userId))
                .orderByTaskCreateTime()
                .desc()
                .list();
        if (CollectionUtils.isNotEmpty(list)) {
            return list.stream().map(WorkflowTask::new).collect(Collectors.toList());
        }
        return new ArrayList<>();
    }


    /**
     * 查询已部署的资源
     */
    public static List<DeploymentImplClass> selectDeployment(){
        RepositoryService bean = SpringUtils.getBean(RepositoryService.class);
        List<Deployment> deployments = bean.createDeploymentQuery().list();
        if (CollectionUtils.isNotEmpty(deployments)) {
            return deployments.stream().map(DeploymentImplClass::deploymentFactory).collect(Collectors.toList());
        }
        return new ArrayList<>();
    }

    /**
     * 查询某节点的出线节点列表办理人列表,如果节点id为空则返回第一个节点的所有出线列表办理人IDS
     * @param workflowTaskId instanceByKey
     * @return
     */
    public static List<UserTaskVo> selectNextTransactors(String workflowTaskId, String instanceByKey){
        List<UserTask> userTaskVos = new ArrayList<>();
       if(StringUtils.isBlank(workflowTaskId) && StringUtils.isBlank(instanceByKey) ){
           throw new SecurityException("任务ID或流程KEY均为空");
        }
        TaskService taskService = SpringUtils.getBean(TaskService.class);
        RuntimeService runtimeService = SpringUtils.getBean(RuntimeService.class);
        RepositoryService repositoryService = SpringUtils.getBean(RepositoryService.class);
        if (StringUtils.isNotEmpty(workflowTaskId)) {
            Optional.ofNullable(taskService.createTaskQuery().taskId(workflowTaskId).singleResult()).ifPresent(task -> {
                String processDefinitionId = task.getProcessDefinitionId();
                // 查询流程定义的 BPMN 模型
                BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
                if (bpmnModel != null) {
                    // 获取当前任务节点的所有出线
                    List<FlowElement> flowElements = bpmnModel.getProcesses().get(0).findFlowElementsOfType(FlowElement.class);
                    for (FlowElement flowElement : flowElements) {
                        if (flowElement instanceof UserTask && flowElement.getId().equals(task.getTaskDefinitionKey())) {
                            // 返回当前用户任务节点的所有出线
                            userTaskVos.add(((UserTask) flowElement));
                        }
                    }
                }
            });
        }
        return userTaskVos.stream().map(UserTaskVo::new).collect(Collectors.toList());
    }

    public static boolean removeAllRepository(String processDefinitionKey){
        RepositoryService repositoryService = SpringUtils.getBean(RepositoryService.class);
        Optional.ofNullable(repositoryService.createProcessDefinitionQuery()
                .processDefinitionKey(processDefinitionKey)
                .latestVersion()
                .singleResult()).ifPresent(processDefinition -> repositoryService.deleteDeployment(processDefinition.getDeploymentId(), Boolean.TRUE));
        return Boolean.TRUE;
    }

    public static boolean removeAllInstance(List<String> processInstanceIds){
        RuntimeService runtimeService = SpringUtils.getBean(RuntimeService.class);
        processInstanceIds.forEach(processInstanceId -> runtimeService.deleteProcessInstance(processInstanceId, "已删除"));
        return Boolean.TRUE;
    }

    public static boolean removeHistory(List<String> processInstanceIds){
        HistoryService historyService = SpringUtils.getBean(HistoryService.class);
        processInstanceIds.forEach(historyService::deleteHistoricProcessInstance);
        return Boolean.TRUE;
    }

    public static List<ProcessDefinition> selectDefinitions(){
        RepositoryService repositoryService = SpringUtils.getBean(RepositoryService.class);
        return repositoryService.createProcessDefinitionQuery().list();
    }

    public static List<Deployment> selectDeployments(){
        RepositoryService repositoryService = SpringUtils.getBean(RepositoryService.class);
        return repositoryService.createDeploymentQuery().list();
    }

    public static List<WorkflowTask> selsectTaskOnList(Long userId){
        userId = Objects.isNull(userId)?getUserId():userId;
        List<WorkflowTask> workflowTasks = selectDone(userId);
        if (!workflowTasks.isEmpty()){
            List<String> collect = workflowTasks.stream().map(WorkflowTask::getWorkflowTaskId).collect(Collectors.toList());
            List<WorkflowTask> res = selectDoneNoFinished(userId);
            res.removeIf(workflowTask ->  !collect.contains(workflowTask.getWorkflowTaskId()));
            return res;
        }
        return new ArrayList<>();
    }

    public static Boolean doThisTask(String workflowTaskId, String opinion,Boolean pass){
        try {
            TaskService taskService = SpringUtils.getBean(TaskService.class);
            Task task = taskService.createTaskQuery().taskId(workflowTaskId).singleResult();
//            taskService.claim(taskId,String.valueOf(getUserId()));
            taskService.setAssignee(workflowTaskId,String.valueOf(getUserId()));
            taskService.addComment(workflowTaskId,task.getProcessInstanceId(),Optional.ofNullable(opinion).orElse(pass?COMMENTS_DEFAULT_VALUE:COMMENTS_NO_PASS_VALUE));
            taskService.complete(workflowTaskId,new HashMap<String,Object>(){{
                put(CONDITION_VARIABLE,pass?PASS:NO_PASS);
            }});
        }catch (ActivitiObjectNotFoundException e){
            throw new ServiceException("当前任务已办理,任务ID为:" + workflowTaskId);
        }
        return Boolean.TRUE;
    }

    public static List<ProcessInstance> selectInstances(){
        return SpringUtils.getBean(RuntimeService.class).createProcessInstanceQuery().list();
    }
    public static <T> TableDataInfo<T> doWorkflowTaskTableDataInfo(Integer pageNum, Integer pageSize, List<T> t) {
        pageNum = Objects.isNull(pageNum)?1:pageNum;
        pageSize = Objects.isNull(pageSize)?10:pageSize;
        if (CollectionUtils.isNotEmpty(t)) {
            TableDataInfo<T> tableDataInfo = new TableDataInfo<>();
            tableDataInfo.setTotal(t.size());
            tableDataInfo.setCode(200);
            tableDataInfo.setData(t.stream()
                    .skip((long) (pageNum - 1) * pageSize)
                    .limit(pageSize)
                    .collect(Collectors.toList()));
            return tableDataInfo;
        }
        return null;
    }
}

实体类代码

import com.eam.common.core.domain.entity.SysUser;
import com.eam.common.exception.ServiceException;
import com.eam.common.utils.spring.SpringUtils;
import com.eam.mes.group.domain.SysGroup;
import com.eam.mes.group.service.ISysGroupService;
import com.eam.system.mapper.SysUserMapper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.activiti.bpmn.model.UserTask;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@AllArgsConstructor
@NoArgsConstructor
@Data
@ApiModel(value = "用户任务对象", description = "用户任务对象")
public class UserTaskVo {

    @ApiModelProperty(value = "用户任务名称")
    private String taskName;
    @ApiModelProperty(value = "用户任务办理人Id",notes = "可能为空,如果为空参考候选人或候选群组")
    private String assignee;
    @ApiModelProperty(value = "用户任务办理人用户名")
    private String assigneeName;
    @ApiModelProperty(value = "用户任务办理人昵称")
    private String assigneeNickName;
    @ApiModelProperty(value = "候选人列表")
    private List<User> candidateUsers = new ArrayList<>();
    @ApiModelProperty(value = "候选组列表")
    private List<SysGroup> candidateGroups = new ArrayList<>();

    public UserTaskVo(UserTask userTask) {
        this.assignee = userTask.getAssignee();
        this.taskName = userTask.getName();
        SysUserMapper bean = SpringUtils.getBean(SysUserMapper.class);
        if (Objects.nonNull(this.assignee)){
            SysUser sysUser = bean.selectUserById(Long.valueOf(this.assignee));
            if (Objects.isNull(sysUser)){
                throw new ServiceException("没有找到该用户!用户ID为" + this.assignee);
            }
            this.assigneeName = sysUser.getUserName();
            this.assigneeNickName = sysUser.getNickName();
        }
        if (!userTask.getCandidateUsers().isEmpty()){
            userTask.getCandidateUsers().forEach(s -> candidateUsers.add(new User(bean.selectUserById(Long.valueOf(s)))));
        }
        if (!userTask.getCandidateGroups().isEmpty()) {
            ISysGroupService iSysGroupService = SpringUtils.getBean(ISysGroupService.class);
            List<SysGroup> sysGroups = iSysGroupService.listByIds(userTask.getCandidateGroups());
            if (sysGroups.isEmpty()) {
                throw new ServiceException("没有找到用户组!用户组列表为" + String.join(",",userTask.getCandidateGroups()));
            }
            Map<Long, List<SysGroup>> collect = sysGroups.stream().collect(Collectors.groupingBy(SysGroup::getGroupId));
            userTask.getCandidateGroups().forEach(s -> candidateGroups.add(new SysGroup(collect.get(Long.valueOf(s)))));
        }

    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ApiModel(value = "用户对象", description = "用户对象")
    static class User{

        @ApiModelProperty(value = "用户ID")
        private String assignee;
        @ApiModelProperty(value = "用户名")
        private String assigneeName;
        @ApiModelProperty(value = "用户昵称")
        private String assigneeNickName;
        public User(SysUser sysUser) {
            this.assignee = String.valueOf(sysUser.getUserId());
            this.assigneeName = sysUser.getUserName();
            this.assigneeNickName = sysUser.getNickName();
        }
    }
}

import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.activiti.engine.task.DelegationState;
import org.activiti.engine.task.TaskInfo;

import java.util.Date;
import java.util.Map;

@EqualsAndHashCode(callSuper = true)
@Data
@AllArgsConstructor
@NoArgsConstructor
@ApiModel(value = "流程任务对象",description = "流程任务对象,返回我的已办及我的待办以及任务操作")
public class WorkflowTask extends WorkflowTaskAbstract{
    public WorkflowTask(TaskInfo info) {
        doCopy(info);
    }
    @ApiModelProperty(value = "本地化名称",notes = "为任务设置可选的本地化名称(可选)")
    private String localizedName;
    @ApiModelProperty(value = "本地化描述",notes = "为任务设置可选的本地化描述(可选)")
    private String localizedDescription;
    @ApiModelProperty(value = "任务描述",notes = "任务描述")
    private String description;
    @ApiModelProperty(value = "紧急程度",notes = "此任务的重要性/紧急程度的指示")
    private int priority;
    @ApiModelProperty(value = "任务负责人",notes = "负责此任务的人员的userId")
    private String owner;
    @ApiModelProperty(value = "委托状态",notes = "委托状态")
    private DelegationState delegationState;
    @ApiModelProperty(value = "截止日期",notes = "更改任务的截止日期")
    private Date dueDate;
    @ApiModelProperty(value = "任务类别",notes = "更改任务类别。这是一个可选字段，允许将任务“标记”为属于某个类别")
    private String category;
    @ApiModelProperty(value = "父任务ID",notes = "该任务是其子任务的父任务")
    private String parentTaskId;
    @ApiModelProperty(value = "租户ID",notes = "该任务的租户标识符",hidden = true)
    @JsonIgnore
    private String tenantId;
    @ApiModelProperty(value = "任务的表单键",notes = "任务表单键",hidden = true)
    @JsonIgnore
    private String formKey;
    @ApiModelProperty(value = "此任务是否已挂起",notes = "此任务是否已挂起")
    private boolean isSuspended;
    @ApiModelProperty(value = "执行路径ID",notes = "执行路径的引用")
    private String executionId;
    @ApiModelProperty(value = "流程实例ID",notes = "流程实例的引用")
    private String processInstanceId;
    @ApiModelProperty(value = "流程定义ID",notes = "流程定义的引用")
    private String processDefinitionId;
    @ApiModelProperty(value = "创建时间",notes = "创建此任务的日期/时间")
    private Date createTime;
    @ApiModelProperty(value = "活动ID",notes = "定义此任务的流程中的活动ID",hidden = true)
    @JsonIgnore
    private String taskDefinitionKey;
    @ApiModelProperty(value = "本地任务变量",notes = "如果任务查询中请求，则返回本地任务变量",hidden = true)
    @JsonIgnore
    private Map<String, Object> taskLocalVariables;

    @ApiModelProperty(value = "领取时间",notes = "该任务的领取时间")
    private Date claimTime;

    @ApiModelProperty(value = "流程变量",notes = "任务查询中请求，则返回流程变量",hidden = true)
    @JsonIgnore
    private Map<String, Object> processVariables;

    @ApiModelProperty(value = "删除原因",notes = "此任务被删除的原因{'已完成' | '已删除'|任何其他用户定义的字符串}。",hidden = true)
    private String deleteReason;

    @ApiModelProperty(value = "任务开始的时间",notes = "任务开始的时间")
    private Date startTime;

    @ApiModelProperty(value = "任务开始的时间",notes = "任务开始的时间")
    private Date endTime;

    @ApiModelProperty(value = "执行耗时",notes = "EndTime()和StartTime()之间的差异（以毫秒为单位）。")
    private Long durationInMillis;

    @ApiModelProperty(value = "工作耗时",notes = "EndTime()和ClaimTime()之间的差异（以毫秒为单位）。")
    private Date workTimeInMillis;
}

import cn.hutool.core.bean.BeanUtil;
import com.eam.common.core.domain.entity.SysUser;
import com.eam.common.exception.ServiceException;
import com.eam.common.utils.spring.SpringUtils;
import com.eam.system.mapper.SysUserMapper;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.activiti.engine.task.TaskInfo;

import java.util.Objects;

@Data
@AllArgsConstructor
@NoArgsConstructor
public abstract class WorkflowTaskAbstract {

protected  void doCopy(T taskInfo){
    BeanUtil.copyProperties(taskInfo,this);
    if (Objects.nonNull(this.assignee)) {
        try {
            SysUser sysUser = SpringUtils.getBean(SysUserMapper.class).selectUserById(Long.valueOf(this.assignee));
            this.assigneeName = sysUser.getUserName();
            this.assigneeNickName = sysUser.getNickName();
        }catch (Exception e){
            throw new ServiceException("没有找到办理人!用户ID为" + this.assignee);
        }
    }
    this.WorkflowTaskId = taskInfo.getId();
    this.WorkflowTaskName = taskInfo.getName();
}
@ApiModelProperty(value = "流程任务对象ID")
protected String WorkflowTaskId;
@ApiModelProperty(value = "流程任务名称")
protected String WorkflowTaskName;
@ApiModelProperty(value = "任务办理人ID",notes = "任务办理人ID",required = true)
protected String assignee;
@ApiModelProperty(value = "任务办理人名称",notes = "任务办理人名称",required = true)
protected String assigneeName;
@ApiModelProperty(value = "任务办理人昵称",notes = "任务办理人昵称",required = true)
protected String assigneeNickName;

}