添加流程任务处理

src/main/java/com/qs/serve/modules/bpm/service/IFlowInstanceService.java

@@ -0,0 +1,59 @@
+package com.qs.serve.modules.bpm.service;
+
+import com.qs.serve.modules.bpm.entity.vo.FlowTaskVo;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.task.api.Task;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 流程实例服务
+ * @author YenHex
+ * @since 2022/8/22
+ */
+public interface IFlowInstanceService {
+
+    List<Task> queryListByInstanceId(String instanceId);
+
+    /**
+     * 结束流程实例
+     *
+     * @param vo
+     */
+    void stopProcessInstance(FlowTaskVo vo);
+
+    /**
+     * 激活或挂起流程实例
+     *
+     * @param state      状态
+     * @param instanceId 流程实例ID
+     */
+    void updateState(Integer state, String instanceId);
+
+    /**
+     * 删除流程实例ID
+     *
+     * @param instanceId   流程实例ID
+     * @param deleteReason 删除原因
+     */
+    void delete(String instanceId, String deleteReason);
+
+    /**
+     * 根据实例ID查询历史实例数据
+     *
+     * @param processInstanceId
+     * @return
+     */
+    HistoricProcessInstance getHistoricProcessInstanceById(String processInstanceId);
+
+    /**
+     * 根据流程定义ID启动流程实例
+     *
+     * @param procDefId 流程定义Id
+     * @param variables 流程变量
+     * @return
+     */
+    void startProcessInstanceById(String procDefId, Map<String, Object> variables);
+
+}

src/main/java/com/qs/serve/modules/bpm/service/IFlowTaskService.java

@@ -0,0 +1,158 @@
+package com.qs.serve.modules.bpm.service;
+
+import com.qs.serve.common.model.dto.R;
+import com.qs.serve.modules.bpm.entity.vo.FlowTaskVo;
+import org.flowable.task.api.Task;
+
+/**
+ * 任务服务层
+ * @author YenHex
+ * @since 2022/8/22
+ */
+public interface IFlowTaskService {
+
+    /**
+     * 审批任务
+     * @param task 请求实体参数
+     */
+    R<?> complete(FlowTaskVo task);
+
+    /**
+     * 驳回任务
+     *
+     * @param flowTaskVo
+     */
+    void taskReject(FlowTaskVo flowTaskVo);
+
+
+    /**
+     * 退回任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void taskReturn(FlowTaskVo flowTaskVo);
+
+    /**
+     * 获取所有可回退的节点
+     *
+     * @param flowTaskVo
+     * @return
+     */
+    R<?> findReturnTaskList(FlowTaskVo flowTaskVo);
+
+    /**
+     * 删除任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void deleteTask(FlowTaskVo flowTaskVo);
+
+    /**
+     * 认领/签收任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void claim(FlowTaskVo flowTaskVo);
+
+    /**
+     * 取消认领/签收任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void unClaim(FlowTaskVo flowTaskVo);
+
+    /**
+     * 委派任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void delegateTask(FlowTaskVo flowTaskVo);
+
+
+    /**
+     * 转办任务
+     *
+     * @param flowTaskVo 请求实体参数
+     */
+    void assignTask(FlowTaskVo flowTaskVo);
+
+    /**
+     * 我发起的流程
+     * @param pageNum
+     * @param pageSize
+     * @return
+     */
+    R<?> myProcess(Integer pageNum, Integer pageSize);
+
+    /**
+     * 取消申请
+     * @param flowTaskVo
+     * @return
+     */
+    R<?> stopProcess(FlowTaskVo flowTaskVo);
+
+    /**
+     * 撤回流程
+     * @param flowTaskVo
+     * @return
+     */
+    R<?> revokeProcess(FlowTaskVo flowTaskVo);
+
+
+    /**
+     * 代办任务列表
+     *
+     * @param pageNum  当前页码
+     * @param pageSize 每页条数
+     * @return
+     */
+    R<?> todoList(Integer pageNum, Integer pageSize);
+
+
+    /**
+     * 已办任务列表
+     *
+     * @param pageNum  当前页码
+     * @param pageSize 每页条数
+     * @return
+     */
+    R<?> finishedList(Integer pageNum, Integer pageSize);
+
+    /**
+     * 流程历史流转记录
+     *
+     * @param procInsId 流程实例Id
+     * @return
+     */
+    R<?> flowRecord(String procInsId,String deployId);
+
+    /**
+     * 根据任务ID查询挂载的表单信息
+     *
+     * @param taskId 任务Id
+     * @return
+     */
+    Task getTaskForm(String taskId);
+
+
+    /**
+     * 获取流程执行过程
+     * @param procInsId
+     * @return
+     */
+    R<?> getFlowViewer(String procInsId,String executionId);
+
+    /**
+     * 获取流程变量
+     * @param taskId
+     * @return
+     */
+    R<?> processVariables(String taskId);
+
+    /**
+     * 获取下一节点
+     * @param flowTaskVo 任务
+     * @return
+     */
+    R<?> getNextFlowNode(FlowTaskVo flowTaskVo);
+}

src/main/java/com/qs/serve/modules/bpm/service/impl/IFlowInstanceServiceImpl.java

@@ -0,0 +1,116 @@
+package com.qs.serve.modules.bpm.service.impl;
+
+import com.qs.serve.common.util.Assert;
+import com.qs.serve.common.util.AuthContextUtils;
+import com.qs.serve.modules.bpm.conf.FlowServiceFactory;
+import com.qs.serve.modules.bpm.entity.vo.FlowTaskVo;
+import com.qs.serve.modules.bpm.service.IFlowInstanceService;
+import lombok.extern.slf4j.Slf4j;
+import org.flowable.common.engine.api.FlowableObjectNotFoundException;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.task.api.Task;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * @author YenHex
+ * @since 2022/8/22
+ */
+@Service
+@Slf4j
+public class IFlowInstanceServiceImpl extends FlowServiceFactory implements IFlowInstanceService {
+
+    @Override
+    public List<Task> queryListByInstanceId(String instanceId) {
+        List<Task> list = taskService.createTaskQuery().processInstanceId(instanceId).active().list();
+        return list;
+    }
+
+    /**
+     * 结束流程实例
+     * @param vo
+     */
+    @Override
+    public void stopProcessInstance(FlowTaskVo vo) {
+        String taskId = vo.getTaskId();
+        //结束流程实例
+    }
+
+    /**
+     * 激活或挂起流程实例
+     * @param state      状态
+     * @param instanceId 流程实例ID
+     */
+    @Override
+    public void updateState(Integer state, String instanceId) {
+        // 激活
+        if (state == 1) {
+            runtimeService.activateProcessInstanceById(instanceId);
+        }
+        // 挂起
+        if (state == 2) {
+            runtimeService.suspendProcessInstanceById(instanceId);
+        }
+    }
+
+    /**
+     * 删除流程实例ID
+     * @param instanceId   流程实例ID
+     * @param deleteReason 删除原因
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(String instanceId, String deleteReason) {
+        // 查询历史数据
+        HistoricProcessInstance historicProcessInstance = getHistoricProcessInstanceById(instanceId);
+        if (historicProcessInstance.getEndTime() != null) {
+            historyService.deleteHistoricProcessInstance(historicProcessInstance.getId());
+            return;
+        }
+        // 删除流程实例
+        runtimeService.deleteProcessInstance(instanceId, deleteReason);
+        // 删除历史流程实例
+        historyService.deleteHistoricProcessInstance(instanceId);
+    }
+
+    /**
+     * 根据实例ID查询历史实例数据
+     * @param processInstanceId
+     * @return
+     */
+    @Override
+    public HistoricProcessInstance getHistoricProcessInstanceById(String processInstanceId) {
+        HistoricProcessInstance historicProcessInstance =
+                historyService.createHistoricProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
+        if (Objects.isNull(historicProcessInstance)) {
+            throw new FlowableObjectNotFoundException("流程实例不存在: " + processInstanceId);
+        }
+        return historicProcessInstance;
+    }
+
+    /**
+     * 根据流程定义ID启动流程实例
+     * @param procDefId 流程定义Id
+     * @param variables 流程变量
+     * @return
+     */
+    @Override
+    public void startProcessInstanceById(String procDefId, Map<String, Object> variables) {
+        try {
+            // 设置流程发起人Id到流程中
+            String userId = AuthContextUtils.getSysUserId();
+            variables.put("initiator",userId);
+            variables.put("_FLOWABLE_SKIP_EXPRESSION_ENABLED", true);
+            runtimeService.startProcessInstanceById(procDefId, variables);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Assert.throwEx("启动流程失败");
+    }
+
+}

src/main/java/com/qs/serve/modules/bpm/service/impl/IFlowTaskServiceImpl.java

@@ -0,0 +1,448 @@
+package com.qs.serve.modules.bpm.service.impl;
+
+import com.qs.serve.common.model.dto.R;
+import com.qs.serve.common.util.Assert;
+import com.qs.serve.common.util.AuthContextUtils;
+import com.qs.serve.common.util.CollectionUtil;
+import com.qs.serve.modules.bpm.common.enums.FlowComment;
+import com.qs.serve.modules.bpm.common.util.FlowableUtils;
+import com.qs.serve.modules.bpm.conf.FlowServiceFactory;
+import com.qs.serve.modules.bpm.entity.dto.FlowTaskDto;
+import com.qs.serve.modules.bpm.entity.vo.FlowTaskVo;
+import com.qs.serve.modules.bpm.service.IFlowTaskService;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.google.common.collect.Lists;
+import com.qs.serve.modules.sys.entity.SysDept;
+import com.qs.serve.modules.sys.entity.SysUser;
+import com.qs.serve.modules.sys.service.SysDeptService;
+import com.qs.serve.modules.sys.service.SysUserService;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.flowable.bpmn.model.Process;
+import org.flowable.bpmn.model.*;
+import org.flowable.common.engine.api.FlowableException;
+import org.flowable.common.engine.api.FlowableObjectNotFoundException;
+import org.flowable.common.engine.api.query.QueryProperty;
+import org.flowable.common.engine.impl.identity.Authentication;
+import org.flowable.engine.ProcessEngineConfiguration;
+import org.flowable.engine.history.HistoricActivityInstance;
+import org.flowable.engine.history.HistoricProcessInstance;
+import org.flowable.engine.history.HistoricProcessInstanceQuery;
+import org.flowable.engine.impl.ActivityInstanceQueryProperty;
+import org.flowable.engine.repository.ProcessDefinition;
+import org.flowable.engine.runtime.ActivityInstance;
+import org.flowable.engine.runtime.Execution;
+import org.flowable.engine.runtime.ProcessInstance;
+import org.flowable.engine.task.Comment;
+import org.flowable.identitylink.api.history.HistoricIdentityLink;
+import org.flowable.image.ProcessDiagramGenerator;
+import org.flowable.task.api.DelegationState;
+import org.flowable.task.api.Task;
+import org.flowable.task.api.TaskQuery;
+import org.flowable.task.api.history.HistoricTaskInstance;
+import org.flowable.task.api.history.HistoricTaskInstanceQuery;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.annotation.Resource;
+import java.io.InputStream;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.Collection;
+import java.util.Objects;
+
+/**
+ * @author YenHex
+ * @since 2022/8/22
+ */
+@Slf4j
+@Service
+@AllArgsConstructor
+public class IFlowTaskServiceImpl extends FlowServiceFactory implements IFlowTaskService {
+
+    private final SysUserService sysUserService;
+    private final SysDeptService sysDeptService;
+
+    /**
+     * 完成任务
+     * @param taskVo
+     * @return
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public R<?> complete(FlowTaskVo taskVo) {
+        Task task = taskService.createTaskQuery().taskId(taskVo.getTaskId()).singleResult();
+        if (Objects.isNull(task)) {
+            return R.error("任务不存在");
+        }
+        if (DelegationState.PENDING.equals(task.getDelegationState())) {
+            taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.DELEGATE.getType(), taskVo.getComment());
+            taskService.resolveTask(taskVo.getTaskId(), taskVo.getValues());
+        } else {
+            taskService.addComment(taskVo.getTaskId(), taskVo.getInstanceId(), FlowComment.NORMAL.getType(), taskVo.getComment());
+            String userId = AuthContextUtils.getSysUserId();
+            taskService.setAssignee(taskVo.getTaskId(), userId);
+            taskService.complete(taskVo.getTaskId(), taskVo.getValues());
+        }
+        return R.ok();
+    }
+
+    /**
+     * TODO 驳回任务
+     * @param flowTaskVo
+     */
+    @Override
+    public void taskReject(FlowTaskVo flowTaskVo) {
+        if (taskService.createTaskQuery().taskId(flowTaskVo.getTaskId()).singleResult().isSuspended()) {
+            Assert.throwEx("任务处于挂起状态");
+        }
+    }
+
+    /**
+     * 退回任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    public void taskReturn(FlowTaskVo flowTaskVo) {
+
+    }
+
+    /**
+     * 获取所有可回退的节点
+     * @param flowTaskVo
+     * @return
+     */
+    @Override
+    public R<?> findReturnTaskList(FlowTaskVo flowTaskVo) {
+        // 当前任务 task
+        Task task = taskService.createTaskQuery().taskId(flowTaskVo.getTaskId()).singleResult();
+        // 获取流程定义信息
+        ProcessDefinition processDefinition = repositoryService.createProcessDefinitionQuery().processDefinitionId(task.getProcessDefinitionId()).singleResult();
+        // 获取所有节点信息，暂不考虑子流程情况
+        Process process = repositoryService.getBpmnModel(processDefinition.getId()).getProcesses().get(0);
+        Collection<FlowElement> flowElements = process.getFlowElements();
+        // 获取当前任务节点元素
+        UserTask source = null;
+        if (flowElements != null) {
+            for (FlowElement flowElement : flowElements) {
+                // 类型为用户节点
+                if (flowElement.getId().equals(task.getTaskDefinitionKey())) {
+                    source = (UserTask) flowElement;
+                }
+            }
+        }
+        // 获取节点的所有路线
+        List<List<UserTask>> roads = FlowableUtils.findRoad(source, null, null, null);
+        // 可回退的节点列表
+        List<UserTask> userTaskList = new ArrayList<>();
+        for (List<UserTask> road : roads) {
+            if (userTaskList.size() == 0) {
+                // 还没有可回退节点直接添加
+                userTaskList = road;
+            } else {
+                // 如果已有回退节点，则比对取交集部分
+                userTaskList.retainAll(road);
+            }
+        }
+        return R.ok(userTaskList);
+    }
+
+    /**
+     * 删除任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    public void deleteTask(FlowTaskVo flowTaskVo) {
+        // todo 待确认删除任务是物理删除任务 还是逻辑删除，让这个任务直接通过？
+        taskService.deleteTask(flowTaskVo.getTaskId(), flowTaskVo.getComment());
+    }
+
+    /**
+     * 认领/签收任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void claim(FlowTaskVo flowTaskVo) {
+        taskService.claim(flowTaskVo.getTaskId(), flowTaskVo.getUserId());
+    }
+
+    /**
+     * 取消认领/签收任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void unClaim(FlowTaskVo flowTaskVo) {
+        taskService.unclaim(flowTaskVo.getTaskId());
+    }
+
+    /**
+     * 委派任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delegateTask(FlowTaskVo flowTaskVo) {
+        taskService.delegateTask(flowTaskVo.getTaskId(), flowTaskVo.getAssignee());
+    }
+
+    /**
+     * 转办任务
+     * @param flowTaskVo 请求实体参数
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void assignTask(FlowTaskVo flowTaskVo) {
+        taskService.setAssignee(flowTaskVo.getTaskId(), flowTaskVo.getComment());
+    }
+
+    @Override
+    public R<?> myProcess(Integer pageNum, Integer pageSize) {
+        Page<FlowTaskDto> page = new Page<>();
+        String userId = AuthContextUtils.getSysUserId();
+        HistoricProcessInstanceQuery historicProcessInstanceQuery = historyService.createHistoricProcessInstanceQuery()
+                .startedBy(userId)
+                .orderByProcessInstanceStartTime()
+                .desc();
+        List<HistoricProcessInstance> historicProcessInstances = historicProcessInstanceQuery.listPage(pageSize * (pageNum - 1), pageSize);
+        page.setTotal(historicProcessInstanceQuery.count());
+        List<FlowTaskDto> flowList = new ArrayList<>();
+        for (HistoricProcessInstance hisIns : historicProcessInstances) {
+            FlowTaskDto flowTask = new FlowTaskDto();
+            flowTask.setCreateTime(hisIns.getStartTime());
+            flowTask.setFinishTime(hisIns.getEndTime());
+            flowTask.setProcInsId(hisIns.getId());
+            // 计算耗时
+            if (Objects.nonNull(hisIns.getEndTime())) {
+                long time = hisIns.getEndTime().getTime() - hisIns.getStartTime().getTime();
+                flowTask.setDuration(getDate(time));
+            } else {
+                long time = System.currentTimeMillis() - hisIns.getStartTime().getTime();
+                flowTask.setDuration(getDate(time));
+            }
+            // 流程定义信息
+            ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
+                    .processDefinitionId(hisIns.getProcessDefinitionId())
+                    .singleResult();
+            flowTask.setDeployId(pd.getDeploymentId());
+            flowTask.setProcDefName(pd.getName());
+            flowTask.setProcDefVersion(pd.getVersion());
+            flowTask.setCategory(pd.getCategory());
+            flowTask.setProcDefVersion(pd.getVersion());
+            // 当前所处流程 todo: 本地启动放开以下注释
+//            List<Task> taskList = taskService.createTaskQuery().processInstanceId(hisIns.getId()).list();
+//            if (CollectionUtils.isNotEmpty(taskList)) {
+//                flowTask.setTaskId(taskList.get(0).getId());
+//            } else {
+//                List<HistoricTaskInstance> historicTaskInstance = historyService.createHistoricTaskInstanceQuery().processInstanceId(hisIns.getId()).orderByHistoricTaskInstanceEndTime().desc().list();
+//                flowTask.setTaskId(historicTaskInstance.get(0).getId());
+//            }
+            flowList.add(flowTask);
+        }
+        page.setRecords(flowList);
+        return R.ok(page);
+    }
+
+    /**
+     * 取消申请
+     * @param flowTaskVo
+     * @return
+     */
+    @Override
+    public R<?> stopProcess(FlowTaskVo flowTaskVo) {
+        List<Task> task = taskService.createTaskQuery().processInstanceId(flowTaskVo.getInstanceId()).list();
+        if (CollectionUtil.isEmpty(task)) {
+            Assert.throwEx("流程未启动或已执行完成，取消申请失败");
+        }
+        // 获取当前需撤回的流程实例
+        ProcessInstance processInstance =
+                runtimeService.createProcessInstanceQuery()
+                        .processInstanceId(flowTaskVo.getInstanceId())
+                        .singleResult();
+        BpmnModel bpmnModel = repositoryService.getBpmnModel(processInstance.getProcessDefinitionId());
+        if (Objects.nonNull(bpmnModel)) {
+            Process process = bpmnModel.getMainProcess();
+            List<EndEvent> endNodes = process.findFlowElementsOfType(EndEvent.class, false);
+            if (CollectionUtil.isNotEmpty(endNodes)) {
+                //SysUser loginUser = AuthContextUtils.getSysUserId();
+                Authentication.setAuthenticatedUserId(AuthContextUtils.getSysUserId());
+//                taskService.addComment(task.getId(), processInstance.getProcessInstanceId(), FlowComment.STOP.getType(),
+//                        StringUtils.isBlank(flowTaskVo.getComment()) ? "取消申请" : flowTaskVo.getComment());
+                // 获取当前流程最后一个节点
+                String endId = endNodes.get(0).getId();
+                List<Execution> executions =
+                        runtimeService.createExecutionQuery().parentId(processInstance.getProcessInstanceId()).list();
+                List<String> executionIds = new ArrayList<>();
+                executions.forEach(execution -> executionIds.add(execution.getId()));
+                // 变更流程为已结束状态
+                runtimeService.createChangeActivityStateBuilder()
+                        .moveExecutionsToSingleActivityId(executionIds, endId).changeState();
+            }
+        }
+        return R.ok();
+    }
+
+    @Override
+    public R<?> revokeProcess(FlowTaskVo flowTaskVo) {
+        Task task = taskService.createTaskQuery().processInstanceId(flowTaskVo.getInstanceId()).singleResult();
+        if (task == null) {
+            Assert.throwEx("流程未启动或已执行完成，无法撤回");
+        }
+        String userId = AuthContextUtils.getSysUserId();
+        List<HistoricTaskInstance> htiList = historyService.createHistoricTaskInstanceQuery()
+                .processInstanceId(task.getProcessInstanceId())
+                .orderByTaskCreateTime()
+                .asc()
+                .list();
+        String myTaskId = null;
+        HistoricTaskInstance myTask = null;
+        for (HistoricTaskInstance hti : htiList) {
+            if (userId.equals(hti.getAssignee())) {
+                myTaskId = hti.getId();
+                myTask = hti;
+                break;
+            }
+        }
+        if (null == myTaskId) {
+            Assert.throwEx("该任务非当前用户提交，无法撤回");
+        }
+        String processDefinitionId = myTask.getProcessDefinitionId();
+        BpmnModel bpmnModel = repositoryService.getBpmnModel(processDefinitionId);
+        //变量
+//      Map<String, VariableInstance> variables = runtimeService.getVariableInstances(currentTask.getExecutionId());
+        String myActivityId = null;
+        List<HistoricActivityInstance> haiList = historyService.createHistoricActivityInstanceQuery()
+                .executionId(myTask.getExecutionId()).finished().list();
+        for (HistoricActivityInstance hai : haiList) {
+            if (myTaskId.equals(hai.getTaskId())) {
+                myActivityId = hai.getActivityId();
+                break;
+            }
+        }
+        FlowNode myFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(myActivityId);
+        Execution execution = runtimeService.createExecutionQuery().executionId(task.getExecutionId()).singleResult();
+        String activityId = execution.getActivityId();
+        FlowNode flowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(activityId);
+        //TODO 记录原活动方向
+        List<SequenceFlow> oriSequenceFlows = new ArrayList<>(flowNode.getOutgoingFlows());
+        return R.ok();
+    }
+
+    /**
+     * 代办任务列表
+     * @param pageNum  当前页码
+     * @param pageSize 每页条数
+     * @return
+     */
+    @Override
+    public R<?> todoList(Integer pageNum, Integer pageSize) {
+        Page<FlowTaskDto> page = new Page<>();
+        String userId = AuthContextUtils.getSysUserId();
+        TaskQuery taskQuery = taskService.createTaskQuery()
+                .active()
+                .includeProcessVariables()
+//                .taskAssignee(userId.toString())
+                .orderByTaskCreateTime().desc();
+        page.setTotal(taskQuery.count());
+        List<Task> taskList = taskQuery.listPage(pageSize * (pageNum - 1), pageSize);
+        List<FlowTaskDto> flowList = new ArrayList<>();
+        for (Task task : taskList) {
+            FlowTaskDto flowTask = new FlowTaskDto();
+            // 当前流程信息
+            flowTask.setTaskId(task.getId());
+            flowTask.setTaskDefKey(task.getTaskDefinitionKey());
+            flowTask.setCreateTime(task.getCreateTime());
+            flowTask.setProcDefId(task.getProcessDefinitionId());
+            flowTask.setExecutionId(task.getExecutionId());
+            flowTask.setTaskName(task.getName());
+            // 流程定义信息
+            ProcessDefinition pd = repositoryService.createProcessDefinitionQuery()
+                    .processDefinitionId(task.getProcessDefinitionId())
+                    .singleResult();
+            flowTask.setDeployId(pd.getDeploymentId());
+            flowTask.setProcDefName(pd.getName());
+            flowTask.setProcDefVersion(pd.getVersion());
+            flowTask.setProcInsId(task.getProcessInstanceId());
+
+            // 流程发起人信息
+            HistoricProcessInstance historicProcessInstance = historyService.createHistoricProcessInstanceQuery()
+                    .processInstanceId(task.getProcessInstanceId())
+                    .singleResult();
+            SysUser startUser = sysUserService.getById(historicProcessInstance.getStartUserId());
+//            SysUser startUser = sysUserService.selectUserById(Long.parseLong(task.getAssignee()));
+            flowTask.setStartUserId(startUser.getId());
+            flowTask.setStartUserName(startUser.getName());
+            if(startUser.getDeptId()!=null){
+                SysDept dept = sysDeptService.getById(startUser.getDeptId());
+                flowTask.setStartDeptName(dept.getName());
+            }
+            flowList.add(flowTask);
+        }
+        page.setRecords(flowList);
+        return R.ok(page);
+    }
+
+    @Override
+    public R<?> finishedList(Integer pageNum, Integer pageSize) {
+        return null;
+    }
+
+    @Override
+    public R<?> flowRecord(String procInsId, String deployId) {
+        return null;
+    }
+
+    @Override
+    public Task getTaskForm(String taskId) {
+        return null;
+    }
+
+    @Override
+    public R<?> getFlowViewer(String procInsId, String executionId) {
+        return null;
+    }
+
+    @Override
+    public R<?> processVariables(String taskId) {
+        return null;
+    }
+
+    @Override
+    public R<?> getNextFlowNode(FlowTaskVo flowTaskVo) {
+        return null;
+    }
+
+    /**
+     * 流程完成时间处理
+     * @param ms
+     * @return
+     */
+    private String getDate(long ms) {
+        long day = ms / (24 * 60 * 60 * 1000);
+        long hour = (ms / (60 * 60 * 1000) - day * 24);
+        long minute = ((ms / (60 * 1000)) - day * 24 * 60 - hour * 60);
+        long second = (ms / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - minute * 60);
+
+        if (day > 0) {
+            return day + "天" + hour + "小时" + minute + "分钟";
+        }
+        if (hour > 0) {
+            return hour + "小时" + minute + "分钟";
+        }
+        if (minute > 0) {
+            return minute + "分钟";
+        }
+        if (second > 0) {
+            return second + "秒";
+        } else {
+            return 0 + "秒";
+        }
+    }
+
+}