Microservice/pqs
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

流转工作流程

Browse Source
This commit is contained in:
hongawen
2024-05-12 16:15:34 +08:00
parent 1a9beeed93
commit eb9818dd7f
71 changed files with 3810 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/IBpmActivityService.java Normal file
View File

@@ -0,0 +1,31 @@
package com.njcn.bpm.service.task;
import com.njcn.bpm.pojo.vo.task.BpmActivityVO;
import org.flowable.engine.history.HistoricActivityInstance;
import java.util.List;
/**
* BPM 活动实例 Service 接口
*
* @author 芋道源码
*/
public interface IBpmActivityService {
/**
* 获得指定流程实例的活动实例列表
*
* @param processInstanceId 流程实例的编号
* @return 活动实例列表
*/
List<BpmActivityVO> getActivityListByProcessInstanceId(String processInstanceId);
/**
* 获得执行编号对应的活动实例
*
* @param executionId 执行编号
* @return 活动实例
*/
List<HistoricActivityInstance> getHistoricActivityListByExecutionId(String executionId);
}

186
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/IBpmProcessInstanceService.java
View File

@@ -1,6 +1,9 @@
package com.njcn.bpm.service.task;
import com.njcn.bpm.pojo.dto.BpmProcessInstanceCreateReqDTO;
import com.njcn.bpm.pojo.dto.PageResult;
import com.njcn.bpm.pojo.param.instance.BpmProcessInstanceCancelParam;
import com.njcn.bpm.pojo.param.instance.BpmProcessInstancePageParam;
import org.flowable.engine.delegate.event.FlowableCancelledEvent;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.runtime.ProcessInstance;
@@ -39,59 +42,59 @@ public interface IBpmProcessInstanceService {
String createProcessInstance(String userId, BpmProcessInstanceCreateReqDTO createReqDTO);
//
// /**
// * 获得流程实例列表
// *
// * @param ids 流程实例的编号集合
// * @return 流程实例列表
// */
// List<ProcessInstance> getProcessInstances(Set<String> ids);
//
// /**
// * 获得流程实例 Map
// *
// * @param ids 流程实例的编号集合
// * @return 流程实例列表 Map
// */
// default Map<String, ProcessInstance> getProcessInstanceMap(Set<String> ids) {
// return convertMap(getProcessInstances(ids), ProcessInstance::getProcessInstanceId);
// }
//
// /**
// * 获得历史的流程实例
// *
// * @param id 流程实例的编号
// * @return 历史的流程实例
// */
// HistoricProcessInstance getHistoricProcessInstance(String id);
//
// /**
// * 获得历史的流程实例列表
// *
// * @param ids 流程实例的编号集合
// * @return 历史的流程实例列表
// */
// List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids);
//
// /**
// * 获得历史的流程实例 Map
// *
// * @param ids 流程实例的编号集合
// * @return 历史的流程实例列表 Map
// */
// default Map<String, HistoricProcessInstance> getHistoricProcessInstanceMap(Set<String> ids) {
// return convertMap(getHistoricProcessInstances(ids), HistoricProcessInstance::getId);
// }
//
// /**
// * 获得流程实例的分页
// *
// * @param userId 用户编号
// * @param pageReqVO 分页请求
// * @return 流程实例的分页
// */
// PageResult<HistoricProcessInstance> getProcessInstancePage(Long userId, @Valid BpmProcessInstancePageReqVO pageReqVO);
/**
* 获得流程实例列表
*
* @param ids 流程实例的编号集合
* @return 流程实例列表
*/
List<ProcessInstance> getProcessInstances(Set<String> ids);
/**
* 获得流程实例 Map
*
* @param ids 流程实例的编号集合
* @return 流程实例列表 Map
*/
default Map<String, ProcessInstance> getProcessInstanceMap(Set<String> ids) {
return convertMap(getProcessInstances(ids), ProcessInstance::getProcessInstanceId);
}
/**
* 获得历史的流程实例
*
* @param id 流程实例的编号
* @return 历史的流程实例
*/
HistoricProcessInstance getHistoricProcessInstance(String id);
/**
* 获得历史的流程实例列表
*
* @param ids 流程实例的编号集合
* @return 历史的流程实例列表
*/
List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids);
/**
* 获得历史的流程实例 Map
*
* @param ids 流程实例的编号集合
* @return 历史的流程实例列表 Map
*/
default Map<String, HistoricProcessInstance> getHistoricProcessInstanceMap(Set<String> ids) {
return convertMap(getHistoricProcessInstances(ids), HistoricProcessInstance::getId);
}
/**
* 获得流程实例的分页
*
* @param userId 用户编号
* @param bpmProcessInstancePageParam 分页请求
* @return 流程实例的分页
*/
PageResult<HistoricProcessInstance> getProcessInstancePage(String userId, BpmProcessInstancePageParam bpmProcessInstancePageParam);
//
// /**
// * 创建流程实例（提供给前端）
@@ -103,43 +106,44 @@ public interface IBpmProcessInstanceService {
// String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqVO createReqVO);
//
//
// /**
// * 发起人取消流程实例
// *
// * @param userId 用户编号
// * @param cancelReqVO 取消信息
// */
// void cancelProcessInstanceByStartUser(Long userId, @Valid BpmProcessInstanceCancelReqVO cancelReqVO);
//
// /**
// * 管理员取消流程实例
// *
// * @param userId 用户编号
// * @param cancelReqVO 取消信息
// */
// void cancelProcessInstanceByAdmin(Long userId, BpmProcessInstanceCancelReqVO cancelReqVO);
//
// /**
// * 更新 ProcessInstance 拓展记录为取消
// *
// * @param event 流程取消事件
// */
// void updateProcessInstanceWhenCancel(FlowableCancelledEvent event);
//
// /**
// * 更新 ProcessInstance 拓展记录为完成
// *
// * @param instance 流程任务
// */
// void updateProcessInstanceWhenApprove(ProcessInstance instance);
//
// /**
// * 更新 ProcessInstance 拓展记录为不通过
// *
// * @param id 流程编号
// * @param reason 理由。例如说，审批不通过时，需要传递该值
// */
// void updateProcessInstanceReject(String id, String reason);
/**
* 发起人取消流程实例
*
* @param userId 用户编号
* @param cancelReqVO 取消信息
*/
void cancelProcessInstanceByStartUser(String userId, BpmProcessInstanceCancelParam cancelReqVO);
/**
* 管理员取消流程实例
*
* @param userId 用户编号
* @param cancelReqVO 取消信息
*/
void cancelProcessInstanceByAdmin(String userId, BpmProcessInstanceCancelParam cancelReqVO);
/**
* 更新 ProcessInstance 拓展记录为取消
*
* @param event 流程取消事件
*/
void updateProcessInstanceWhenCancel(FlowableCancelledEvent event);
/**
* 更新 ProcessInstance 拓展记录为完成
*
* @param instance 流程任务
*/
void updateProcessInstanceWhenApprove(ProcessInstance instance);
/**
* 更新 ProcessInstance 拓展记录为不通过
*
* @param id 流程编号
* @param reason 理由。例如说，审批不通过时，需要传递该值
*/
void updateProcessInstanceReject(String id, String reason);
}

187
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/IBpmTaskService.java Normal file
View File

@@ -0,0 +1,187 @@
package com.njcn.bpm.service.task;
import com.njcn.bpm.pojo.dto.PageResult;
import com.njcn.bpm.pojo.param.task.*;
import com.njcn.bpm.utils.CollectionUtils;
import org.flowable.bpmn.model.UserTask;
import org.flowable.task.api.Task;
import org.flowable.task.api.history.HistoricTaskInstance;
import java.util.List;
import java.util.Map;
/**
* 流程任务实例 Service 接口
*
* @author jason
* @author 芋道源码
*/
public interface IBpmTaskService {
/**
* 获得待办的流程任务分页
*
* @param userId 用户编号
* @param bpmTaskQueryParam 分页请求
* @return 流程任务分页
*/
PageResult<Task> getTaskTodoPage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam);
/**
* 获得已办的流程任务分页
*
* @param userId 用户编号
* @param bpmTaskQueryParam 分页请求
* @return 流程任务分页
*/
PageResult<HistoricTaskInstance> getTaskDonePage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam);
/**
* 获得全部的流程任务分页
*
* @param userId 用户编号
* @param bpmTaskQueryParam 分页请求
* @return 流程任务分页
*/
PageResult<HistoricTaskInstance> getTaskPage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam);
/**
* 获得流程任务 Map
*
* @param processInstanceIds 流程实例的编号数组
* @return 流程任务 Map
*/
default Map<String, List<Task>> getTaskMapByProcessInstanceIds(List<String> processInstanceIds) {
return CollectionUtils.convertMultiMap(getTasksByProcessInstanceIds(processInstanceIds),
Task::getProcessInstanceId);
}
/**
* 获得流程任务列表
*
* @param processInstanceIds 流程实例的编号数组
* @return 流程任务列表
*/
List<Task> getTasksByProcessInstanceIds(List<String> processInstanceIds);
/**
* 获得指定流程实例的流程任务列表，包括所有状态的
*
* @param processInstanceId 流程实例的编号
* @return 流程任务列表
*/
List<HistoricTaskInstance> getTaskListByProcessInstanceId(String processInstanceId);
/**
* 通过任务
*
* @param userId 用户编号
* @param bpmTaskApproveParam 通过请求
*/
void approveTask(String userId, BpmTaskApproveParam bpmTaskApproveParam);
/**
* 不通过任务
*
* @param userId 用户编号
* @param bpmTaskRejectParam 不通过请求
*/
void rejectTask(String userId, BpmTaskRejectParam bpmTaskRejectParam);
/**
* 将流程任务分配给指定用户
*
* @param userId 用户编号
* @param reqVO 分配请求
*/
void transferTask(String userId, BpmTaskTransferParam reqVO);
/**
* 更新 Task 状态，在创建时
*
* @param task 任务实体
*/
void updateTaskStatusWhenCreated(Task task);
/**
* 更新 Task 状态，在取消时
*
* @param taskId 任务的编号
*/
void updateTaskStatusWhenCanceled(String taskId);
/**
* 更新 Task 拓展记录，并发送通知
*
* @param task 任务实体
*/
void updateTaskExtAssign(Task task);
/**
* 获取任务
*
* @param id 任务编号
* @return 任务
*/
Task getTask(String id);
/**
* 获取当前任务的可回退的 UserTask 集合
*
* @param id 当前的任务 ID
* @return 可以回退的节点列表
*/
List<UserTask> getUserTaskListByReturn(String id);
/**
* 将任务回退到指定的 targetDefinitionKey 位置
*
* @param userId 用户编号
* @param bpmTaskReturnParam 回退的任务key和当前所在的任务ID
*/
void returnTask(String userId, BpmTaskReturnParam bpmTaskReturnParam);
/**
* 将指定任务委派给其他人处理，等接收人处理后再回到原审批人手中审批
*
* @param userId 用户编号
* @param reqVO 被委派人和被委派的任务编号理由参数
*/
void delegateTask(String userId, BpmTaskDelegateParam reqVO);
/**
* 任务加签
*
* @param userId 被加签的用户和任务 ID，加签类型
* @param reqVO 当前用户 ID
*/
void createSignTask(String userId, BpmTaskSignCreateParam reqVO);
/**
* 任务减签
*
* @param userId 当前用户ID
* @param reqVO 被减签的任务 ID，理由
*/
void deleteSignTask(String userId, BpmTaskSignDeleteParam reqVO);
/**
* 获取指定任务的子任务列表
*
* @param parentTaskId 父任务ID
* @return 子任务列表
*/
List<Task> getTaskListByParentTaskId(String parentTaskId);
//
// /**
// * 通过任务 ID，查询任务名 Map
// *
// * @param taskIds 任务 ID
// * @return 任务 ID 与名字的 Map
// */
// Map<String, String> getTaskNameByTaskIds(Collection<String> taskIds);
}

36
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/IProcessInstanceCopyService.java Normal file
View File

@@ -0,0 +1,36 @@
package com.njcn.bpm.service.task;
import com.baomidou.mybatisplus.extension.service.IService;
import com.njcn.bpm.pojo.po.task.ProcessInstanceCopy;
import java.util.Collection;
/**
* <p>
* BPM 流程实例抄送表 服务类
* </p>
*
* @author hongawen
* @since 2024-05-10
*/
public interface IProcessInstanceCopyService extends IService<ProcessInstanceCopy> {
/**
* 流程实例的抄送
*
* @param userIds 抄送的用户编号
* @param taskId 流程任务编号
*/
void createProcessInstanceCopy(Collection<String> userIds, String taskId);
// /**
// * 获得抄送的流程的分页
// *
// * @param userId 当前登录用户
// * @param pageReqVO 分页请求
// * @return 抄送的分页结果
// */
// PageResult<BpmProcessInstanceCopyDO> getProcessInstanceCopyPage(Long userId, BpmProcessInstanceCopyPageReqVO pageReqVO);
}

41
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/impl/BpmActivityServiceImpl.java Normal file
View File

@@ -0,0 +1,41 @@
package com.njcn.bpm.service.task.impl;
import com.njcn.bpm.pojo.vo.task.BpmActivityVO;
import com.njcn.bpm.service.task.IBpmActivityService;
import com.njcn.bpm.utils.BpmActivityConvert;
import lombok.extern.slf4j.Slf4j;
import org.flowable.engine.HistoryService;
import org.flowable.engine.history.HistoricActivityInstance;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.util.List;
/**
* BPM 活动实例 Service 实现类
*
* @author 芋道源码
*/
@Service
@Slf4j
@Validated
public class BpmActivityServiceImpl implements IBpmActivityService {
@Resource
private HistoryService historyService;
@Override
public List<BpmActivityVO> getActivityListByProcessInstanceId(String processInstanceId) {
List<HistoricActivityInstance> activityList = historyService.createHistoricActivityInstanceQuery()
.processInstanceId(processInstanceId).list();
return BpmActivityConvert.INSTANCE.convertList(activityList);
}
@Override
public List<HistoricActivityInstance> getHistoricActivityListByExecutionId(String executionId) {
return historyService.createHistoricActivityInstanceQuery().executionId(executionId).list();
}
}

332
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/impl/BpmProcessInstanceServiceImpl.java
View File

@@ -1,30 +1,47 @@
package com.njcn.bpm.service.task.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.StrUtil;
import com.njcn.bpm.constant.BpmConstants;
import com.njcn.bpm.enums.BpmDeleteReasonEnum;
import com.njcn.bpm.enums.BpmProcessInstanceStatusEnum;
import com.njcn.bpm.enums.BpmResponseEnum;
import com.njcn.bpm.event.BpmProcessInstanceEventPublisher;
import com.njcn.bpm.pojo.dto.BpmProcessInstanceCreateReqDTO;
import com.njcn.bpm.pojo.dto.PageResult;
import com.njcn.bpm.pojo.param.instance.BpmProcessInstanceCancelParam;
import com.njcn.bpm.pojo.param.instance.BpmProcessInstancePageParam;
import com.njcn.bpm.service.IBpmProcessDefinitionService;
import com.njcn.bpm.service.task.IBpmProcessInstanceService;
import com.njcn.bpm.strategy.BpmTaskCandidateStartUserSelectStrategy;
import com.njcn.bpm.utils.BpmProcessInstanceConvert;
import com.njcn.bpm.utils.CollectionUtils;
import com.njcn.bpm.utils.DateUtils;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.user.api.UserFeignClient;
import com.njcn.user.pojo.po.User;
import com.njcn.user.pojo.vo.UserVO;
import com.njcn.web.factory.PageFactory;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.bpmn.model.UserTask;
import org.flowable.engine.HistoryService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.delegate.event.FlowableCancelledEvent;
import org.flowable.engine.history.HistoricProcessInstance;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.engine.runtime.ProcessInstanceBuilder;
import org.flowable.engine.history.HistoricProcessInstanceQuery;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import com.njcn.bpm.utils.FlowableUtils;
import javax.annotation.Resource;
import javax.validation.Valid;
import java.time.LocalDateTime;
import java.util.*;
@@ -60,9 +77,9 @@ public class BpmProcessInstanceServiceImpl implements IBpmProcessInstanceService
//
@Resource
private UserFeignClient userFeignClient;
//
// @Resource
// private BpmProcessInstanceEventPublisher processInstanceEventPublisher;
@Resource
private BpmProcessInstanceEventPublisher processInstanceEventPublisher;
@Override
public ProcessInstance getProcessInstance(String id) {
@@ -73,61 +90,64 @@ public class BpmProcessInstanceServiceImpl implements IBpmProcessInstanceService
}
//
// @Override
// public List<ProcessInstance> getProcessInstances(Set<String> ids) {
// return runtimeService.createProcessInstanceQuery().processInstanceIds(ids).list();
// }
//
// @Override
// public HistoricProcessInstance getHistoricProcessInstance(String id) {
// return historyService.createHistoricProcessInstanceQuery().processInstanceId(id).includeProcessVariables().singleResult();
// }
//
// @Override
// public List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids) {
// return historyService.createHistoricProcessInstanceQuery().processInstanceIds(ids).list();
// }
//
// @Override
// public PageResult<HistoricProcessInstance> getProcessInstancePage(Long userId,
// BpmProcessInstancePageReqVO pageReqVO) {
// // 通过 BpmProcessInstanceExtDO 表，先查询到对应的分页
// HistoricProcessInstanceQuery processInstanceQuery = historyService.createHistoricProcessInstanceQuery()
// .includeProcessVariables()
// .processInstanceTenantId(FlowableUtils.getTenantId())
// .orderByProcessInstanceStartTime().desc();
// if (userId != null) { // 【我的流程】菜单时，需要传递该字段
// processInstanceQuery.startedBy(String.valueOf(userId));
// } else if (pageReqVO.getStartUserId() != null) { // 【管理流程】菜单时，才会传递该字段
// processInstanceQuery.startedBy(String.valueOf(pageReqVO.getStartUserId()));
// }
// if (StrUtil.isNotEmpty(pageReqVO.getName())) {
// processInstanceQuery.processInstanceNameLike("%" + pageReqVO.getName() + "%");
// }
// if (StrUtil.isNotEmpty(pageReqVO.getProcessDefinitionId())) {
// processInstanceQuery.processDefinitionId("%" + pageReqVO.getProcessDefinitionId() + "%");
// }
// if (StrUtil.isNotEmpty(pageReqVO.getCategory())) {
// processInstanceQuery.processDefinitionCategory(pageReqVO.getCategory());
// }
// if (pageReqVO.getStatus() != null) {
// processInstanceQuery.variableValueEquals(BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS, pageReqVO.getStatus());
// }
// if (ArrayUtil.isNotEmpty(pageReqVO.getCreateTime())) {
// processInstanceQuery.startedAfter(DateUtils.of(pageReqVO.getCreateTime()[0]));
// processInstanceQuery.startedBefore(DateUtils.of(pageReqVO.getCreateTime()[1]));
// }
// // 查询数量
// long processInstanceCount = processInstanceQuery.count();
// if (processInstanceCount == 0) {
// return PageResult.empty(processInstanceCount);
// }
// // 查询列表
// List<HistoricProcessInstance> processInstanceList = processInstanceQuery.listPage(PageUtils.getStart(pageReqVO), pageReqVO.getPageSize());
// return new PageResult<>(processInstanceList, processInstanceCount);
// }
//
@Override
public List<ProcessInstance> getProcessInstances(Set<String> ids) {
return runtimeService.createProcessInstanceQuery().processInstanceIds(ids).list();
}
@Override
public HistoricProcessInstance getHistoricProcessInstance(String id) {
return historyService.createHistoricProcessInstanceQuery().processInstanceId(id).includeProcessVariables().singleResult();
}
@Override
public List<HistoricProcessInstance> getHistoricProcessInstances(Set<String> ids) {
return historyService.createHistoricProcessInstanceQuery().processInstanceIds(ids).list();
}
@Override
public PageResult<HistoricProcessInstance> getProcessInstancePage(String userId, BpmProcessInstancePageParam bpmProcessInstancePageParam) {
// 通过 BpmProcessInstanceExtDO 表，先查询到对应的分页
HistoricProcessInstanceQuery processInstanceQuery = historyService.createHistoricProcessInstanceQuery()
.includeProcessVariables()
.processInstanceTenantId(FlowableUtils.getTenantId())
.orderByProcessInstanceStartTime().desc();
if (userId != null) { // 【我的流程】菜单时，需要传递该字段
processInstanceQuery.startedBy(userId);
} else if (bpmProcessInstancePageParam.getStartUserId() != null) { // 【管理流程】菜单时，才会传递该字段
processInstanceQuery.startedBy(bpmProcessInstancePageParam.getStartUserId());
}
if (StrUtil.isNotEmpty(bpmProcessInstancePageParam.getName())) {
processInstanceQuery.processInstanceNameLike("%" + bpmProcessInstancePageParam.getName() + "%");
}
if (StrUtil.isNotEmpty(bpmProcessInstancePageParam.getProcessDefinitionId())) {
processInstanceQuery.processDefinitionId("%" + bpmProcessInstancePageParam.getProcessDefinitionId() + "%");
}
if (StrUtil.isNotEmpty(bpmProcessInstancePageParam.getCategory())) {
processInstanceQuery.processDefinitionCategory(bpmProcessInstancePageParam.getCategory());
}
if (bpmProcessInstancePageParam.getStatus() != null) {
processInstanceQuery.variableValueEquals(BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS, bpmProcessInstancePageParam.getStatus());
}
String beginTimeStr = bpmProcessInstancePageParam.getSearchBeginTime();
String endTimeStr = bpmProcessInstancePageParam.getSearchEndTime();
LocalDateTime beginTime = LocalDateTimeUtil.parse(beginTimeStr, DatePattern.NORM_DATE_PATTERN);
LocalDateTime endTime = LocalDateTimeUtil.parse(endTimeStr, DatePattern.NORM_DATE_PATTERN);
processInstanceQuery.startedAfter(DateUtils.of(beginTime));
processInstanceQuery.startedBefore(DateUtils.of(endTime));
// 查询数量
long processInstanceCount = processInstanceQuery.count();
if (processInstanceCount == 0) {
return PageResult.empty(processInstanceCount);
}
// 查询列表
int offset = PageFactory.getPageSize(bpmProcessInstancePageParam) * (PageFactory.getPageNum(bpmProcessInstancePageParam) - 1);
List<HistoricProcessInstance> processInstanceList = processInstanceQuery.listPage(offset, PageFactory.getPageSize(bpmProcessInstancePageParam));
return new PageResult<>(processInstanceList, processInstanceCount);
}
// @Override
// @Transactional(rollbackFor = Exception.class)
// public String createProcessInstance(Long userId, @Valid BpmProcessInstanceCreateReqVO createReqVO) {
@@ -139,7 +159,7 @@ public class BpmProcessInstanceServiceImpl implements IBpmProcessInstanceService
// }
@Override
public String createProcessInstance(String userId, @Valid BpmProcessInstanceCreateReqDTO createReqDTO) {
public String createProcessInstance(String userId, BpmProcessInstanceCreateReqDTO createReqDTO) {
// 获得流程定义
ProcessDefinition definition = processDefinitionService.getActiveProcessDefinition(createReqDTO.getProcessDefinitionKey());
// 发起流程
@@ -194,8 +214,8 @@ public class BpmProcessInstanceServiceImpl implements IBpmProcessInstanceService
if (CollUtil.isEmpty(assignees)) {
throw new BusinessException("审批任务(" + userTask.getName() + ")的审批人未配置");
}
List<User> userList = userFeignClient.getUserByIdList(assignees).getData();
Map<String, User> userMap = CollectionUtils.convertMap(userList, User::getId);
List<UserVO> userList = userFeignClient.getUserVOByIdList(assignees).getData();
Map<String, UserVO> userMap = CollectionUtils.convertMap(userList, UserVO::getId);
assignees.forEach(assignee -> {
if (userMap.get(assignee) == null) {
throw new BusinessException("审批任务(" + userTask.getName() + ")的审批人(" + assignee + ")不存在");
@@ -203,101 +223,101 @@ public class BpmProcessInstanceServiceImpl implements IBpmProcessInstanceService
});
});
}
//
// @Override
// public void cancelProcessInstanceByStartUser(Long userId, @Valid BpmProcessInstanceCancelReqVO cancelReqVO) {
// // 1.1 校验流程实例存在
// ProcessInstance instance = getProcessInstance(cancelReqVO.getId());
// if (instance == null) {
// throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
// }
// // 1.2 只能取消自己的
// if (!Objects.equals(instance.getStartUserId(), String.valueOf(userId))) {
// throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF);
// }
//
// // 2. 通过删除流程实例，实现流程实例的取消,
// // 删除流程实例，正则执行任务 ACT_RU_TASK. 任务会被删除。
// deleteProcessInstance(cancelReqVO.getId(),
// BpmDeleteReasonEnum.CANCEL_PROCESS_INSTANCE_BY_START_USER.format(cancelReqVO.getReason()));
//
// // 3. 进一步的处理，交给 updateProcessInstanceCancel 方法
// }
//
// @Override
// public void cancelProcessInstanceByAdmin(Long userId, BpmProcessInstanceCancelReqVO cancelReqVO) {
// // 1.1 校验流程实例存在
// ProcessInstance instance = getProcessInstance(cancelReqVO.getId());
// if (instance == null) {
// throw exception(PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
// }
// // 1.2 管理员取消，不用校验是否为自己的
// AdminUserRespDTO user = adminUserApi.getUser(userId);
//
// // 2. 通过删除流程实例，实现流程实例的取消,
// // 删除流程实例，正则执行任务 ACT_RU_TASK. 任务会被删除。
// deleteProcessInstance(cancelReqVO.getId(),
// BpmDeleteReasonEnum.CANCEL_PROCESS_INSTANCE_BY_ADMIN.format(user.getNickname(), cancelReqVO.getReason()));
//
// // 3. 进一步的处理，交给 updateProcessInstanceCancel 方法
// }
//
// @Override
// public void updateProcessInstanceWhenCancel(FlowableCancelledEvent event) {
// // 1. 判断是否为 Reject 不通过。如果是，则不进行更新.
// // 因为，updateProcessInstanceReject 方法（审批不通过），已经进行更新了
// if (BpmDeleteReasonEnum.isRejectReason((String) event.getCause())) {
// return;
// }
//
// // 2. 更新流程实例 status
// runtimeService.setVariable(event.getProcessInstanceId(), BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS,
// BpmProcessInstanceStatusEnum.CANCEL.getStatus());
//
// // 3. 发送流程实例的状态事件
// // 注意：此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
// HistoricProcessInstance processInstance = getHistoricProcessInstance(event.getProcessInstanceId());
// // 发送流程实例的状态事件
// processInstanceEventPublisher.sendProcessInstanceResultEvent(
// BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.CANCEL.getStatus()));
// }
//
// @Override
// public void updateProcessInstanceWhenApprove(ProcessInstance instance) {
// // 1. 更新流程实例 status
// runtimeService.setVariable(instance.getId(), BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS,
// BpmProcessInstanceStatusEnum.APPROVE.getStatus());
//
// // 2. 发送流程被【通过】的消息
@Override
public void cancelProcessInstanceByStartUser(String userId, BpmProcessInstanceCancelParam cancelReqVO) {
// 1.1 校验流程实例存在
ProcessInstance instance = getProcessInstance(cancelReqVO.getId());
if (instance == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
}
// 1.2 只能取消自己的
if (!Objects.equals(instance.getStartUserId(), String.valueOf(userId))) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_CANCEL_FAIL_NOT_SELF);
}
// 2. 通过删除流程实例，实现流程实例的取消,
// 删除流程实例，正则执行任务 ACT_RU_TASK. 任务会被删除。
deleteProcessInstance(cancelReqVO.getId(),
BpmDeleteReasonEnum.CANCEL_PROCESS_INSTANCE_BY_START_USER.format(cancelReqVO.getReason()));
// 3. 进一步的处理，交给 updateProcessInstanceCancel 方法
}
@Override
public void cancelProcessInstanceByAdmin(String userId, BpmProcessInstanceCancelParam cancelReqVO) {
// 1.1 校验流程实例存在
ProcessInstance instance = getProcessInstance(cancelReqVO.getId());
if (instance == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_CANCEL_FAIL_NOT_EXISTS);
}
// 1.2 管理员取消，不用校验是否为自己的
UserVO user = userFeignClient.getUserById(userId).getData();
// 2. 通过删除流程实例，实现流程实例的取消,
// 删除流程实例，正则执行任务 ACT_RU_TASK. 任务会被删除。
deleteProcessInstance(cancelReqVO.getId(),
BpmDeleteReasonEnum.CANCEL_PROCESS_INSTANCE_BY_ADMIN.format(user.getName(), cancelReqVO.getReason()));
// 3. 进一步的处理，交给 updateProcessInstanceCancel 方法
}
@Override
public void updateProcessInstanceWhenCancel(FlowableCancelledEvent event) {
// 1. 判断是否为 Reject 不通过。如果是，则不进行更新.
// 因为，updateProcessInstanceReject 方法（审批不通过），已经进行更新了
if (BpmDeleteReasonEnum.isRejectReason((String) event.getCause())) {
return;
}
// 2. 更新流程实例 status
runtimeService.setVariable(event.getProcessInstanceId(), BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS,
BpmProcessInstanceStatusEnum.CANCEL.getStatus());
// 3. 发送流程实例的状态事件
// 注意：此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
HistoricProcessInstance processInstance = getHistoricProcessInstance(event.getProcessInstanceId());
// 发送流程实例的状态事件
processInstanceEventPublisher.sendProcessInstanceResultEvent(
BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.CANCEL.getStatus()));
}
@Override
public void updateProcessInstanceWhenApprove(ProcessInstance instance) {
// 1. 更新流程实例 status
runtimeService.setVariable(instance.getId(), BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS,
BpmProcessInstanceStatusEnum.APPROVE.getStatus());
// 2. 发送流程被【通过】的消息
// messageService.sendMessageWhenProcessInstanceApprove(BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceApproveMessage(instance));
//
// // 3. 发送流程实例的状态事件
// // 注意：此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
// HistoricProcessInstance processInstance = getHistoricProcessInstance(instance.getId());
// processInstanceEventPublisher.sendProcessInstanceResultEvent(
// BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.APPROVE.getStatus()));
// }
//
// @Override
// @Transactional(rollbackFor = Exception.class)
// public void updateProcessInstanceReject(String id, String reason) {
// // 1. 更新流程实例 status
// runtimeService.setVariable(id, BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS, BpmProcessInstanceStatusEnum.REJECT.getStatus());
//
// // 2. 删除流程实例，以实现驳回任务时，取消整个审批流程
// ProcessInstance processInstance = getProcessInstance(id);
// deleteProcessInstance(id, StrUtil.format(BpmDeleteReasonEnum.REJECT_TASK.format(reason)));
//
// // 3. 发送流程被【不通过】的消息
// 3. 发送流程实例的状态事件
// 注意：此时如果去查询 ProcessInstance 的话，字段是不全的，所以去查询了 HistoricProcessInstance
HistoricProcessInstance processInstance = getHistoricProcessInstance(instance.getId());
processInstanceEventPublisher.sendProcessInstanceResultEvent(
BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.APPROVE.getStatus()));
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateProcessInstanceReject(String id, String reason) {
// 1. 更新流程实例 status
runtimeService.setVariable(id, BpmConstants.PROCESS_INSTANCE_VARIABLE_STATUS, BpmProcessInstanceStatusEnum.REJECT.getStatus());
// 2. 删除流程实例，以实现驳回任务时，取消整个审批流程
ProcessInstance processInstance = getProcessInstance(id);
deleteProcessInstance(id, StrUtil.format(BpmDeleteReasonEnum.REJECT_TASK.format(reason)));
// 3. 发送流程被【不通过】的消息
// messageService.sendMessageWhenProcessInstanceReject(BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceRejectMessage(processInstance, reason));
//
// // 4. 发送流程实例的状态事件
// processInstanceEventPublisher.sendProcessInstanceResultEvent(
// BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.REJECT.getStatus()));
// }
//
// private void deleteProcessInstance(String id, String reason) {
// runtimeService.deleteProcessInstance(id, reason);
// }
// 4. 发送流程实例的状态事件
processInstanceEventPublisher.sendProcessInstanceResultEvent(
BpmProcessInstanceConvert.INSTANCE.buildProcessInstanceStatusEvent(this, processInstance, BpmProcessInstanceStatusEnum.REJECT.getStatus()));
}
private void deleteProcessInstance(String id, String reason) {
runtimeService.deleteProcessInstance(id, reason);
}
}

836
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/impl/BpmTaskServiceImpl.java Normal file
View File

@@ -0,0 +1,836 @@
package com.njcn.bpm.service.task.impl;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.njcn.bpm.constant.BpmConstants;
import com.njcn.bpm.enums.*;
import com.njcn.bpm.pojo.dto.PageResult;
import com.njcn.bpm.pojo.param.task.*;
import com.njcn.bpm.service.IBpmModelService;
import com.njcn.bpm.service.task.IBpmProcessInstanceService;
import com.njcn.bpm.service.task.IBpmTaskService;
import com.njcn.bpm.service.task.IProcessInstanceCopyService;
import com.njcn.bpm.utils.BpmTaskConvert;
import com.njcn.bpm.utils.BpmnModelUtils;
import com.njcn.bpm.utils.DateUtils;
import com.njcn.bpm.utils.FlowableUtils;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.utils.PubUtils;
import com.njcn.user.api.UserFeignClient;
import com.njcn.user.pojo.po.User;
import com.njcn.user.pojo.vo.UserVO;
import com.njcn.web.factory.PageFactory;
import com.njcn.web.utils.RequestUtil;
import lombok.extern.slf4j.Slf4j;
import org.flowable.bpmn.model.BpmnModel;
import org.flowable.bpmn.model.FlowElement;
import org.flowable.bpmn.model.UserTask;
import org.flowable.engine.HistoryService;
import org.flowable.engine.ManagementService;
import org.flowable.engine.RuntimeService;
import org.flowable.engine.TaskService;
import org.flowable.engine.runtime.ProcessInstance;
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.flowable.task.service.impl.persistence.entity.TaskEntity;
import org.flowable.task.service.impl.persistence.entity.TaskEntityImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronization;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Stream;
import static com.njcn.bpm.utils.CollectionUtils.convertList;
import static com.njcn.bpm.utils.CollectionUtils.convertListByFlatMap;
/**
* 流程任务实例 Service 实现类
*
* @author 芋道源码
* @author jason
*/
@Slf4j
@Service
public class BpmTaskServiceImpl implements IBpmTaskService {
@Resource
private TaskService taskService;
@Resource
private HistoryService historyService;
@Resource
private RuntimeService runtimeService;
@Resource
private ManagementService managementService;
@Resource
private IBpmProcessInstanceService processInstanceService;
@Resource
private IProcessInstanceCopyService processInstanceCopyService;
@Resource
private IBpmModelService bpmModelService;
// @Resource
// private BpmMessageService messageService;
@Resource
private UserFeignClient adminUserApi;
@Override
public PageResult<Task> getTaskTodoPage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam) {
TaskQuery taskQuery = taskService.createTaskQuery()
.taskAssignee(userId) // 分配给自己
.active()
.includeProcessVariables()
.orderByTaskCreateTime().desc(); // 创建时间倒序
if (StrUtil.isNotBlank(bpmTaskQueryParam.getSearchValue())) {
taskQuery.taskNameLike("%" + bpmTaskQueryParam.getSearchValue() + "%");
}
String beginTimeStr = bpmTaskQueryParam.getSearchBeginTime();
String endTimeStr = bpmTaskQueryParam.getSearchEndTime();
LocalDateTime beginTime = LocalDateTimeUtil.parse(beginTimeStr, DatePattern.NORM_DATE_PATTERN);
LocalDateTime endTime = PubUtils.endTimeToLocalDateTime(endTimeStr);
taskQuery.taskCreatedBefore(DateUtils.of(endTime));
taskQuery.taskCreatedAfter(DateUtils.of(beginTime));
long count = taskQuery.count();
if (count == 0) {
return PageResult.empty();
}
int offset = PageFactory.getPageSize(bpmTaskQueryParam) * (PageFactory.getPageNum(bpmTaskQueryParam) - 1);
List<Task> tasks = taskQuery.listPage(offset, PageFactory.getPageSize(bpmTaskQueryParam));
return new PageResult<>(tasks, count);
}
@Override
public PageResult<HistoricTaskInstance> getTaskDonePage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam) {
HistoricTaskInstanceQuery taskQuery = historyService.createHistoricTaskInstanceQuery()
.finished() // 已完成
.taskAssignee(String.valueOf(userId)) // 分配给自己
.includeTaskLocalVariables()
.orderByHistoricTaskInstanceEndTime().desc(); // 审批时间倒序
if (StrUtil.isNotBlank(bpmTaskQueryParam.getSearchValue())) {
taskQuery.taskNameLike("%" + bpmTaskQueryParam.getSearchValue() + "%");
}
String beginTimeStr = bpmTaskQueryParam.getSearchBeginTime();
String endTimeStr = bpmTaskQueryParam.getSearchEndTime();
LocalDateTime beginTime = LocalDateTimeUtil.parse(beginTimeStr, DatePattern.NORM_DATE_PATTERN);
LocalDateTime endTime = PubUtils.endTimeToLocalDateTime(endTimeStr);
taskQuery.taskCreatedBefore(DateUtils.of(endTime));
taskQuery.taskCreatedAfter(DateUtils.of(beginTime));
// 执行查询
long count = taskQuery.count();
if (count == 0) {
return PageResult.empty();
}
int offset = PageFactory.getPageSize(bpmTaskQueryParam) * (PageFactory.getPageNum(bpmTaskQueryParam) - 1);
List<HistoricTaskInstance> tasks = taskQuery.listPage(offset, PageFactory.getPageSize(bpmTaskQueryParam));
return new PageResult<>(tasks, count);
}
@Override
public PageResult<HistoricTaskInstance> getTaskPage(String userId, BpmTaskParam.BpmTaskQueryParam bpmTaskQueryParam) {
HistoricTaskInstanceQuery taskQuery = historyService.createHistoricTaskInstanceQuery()
.includeTaskLocalVariables()
.taskTenantId(FlowableUtils.getTenantId())
.orderByHistoricTaskInstanceEndTime().desc(); // 审批时间倒序
if (StrUtil.isNotBlank(bpmTaskQueryParam.getSearchValue())) {
taskQuery.taskNameLike("%" + bpmTaskQueryParam.getSearchValue() + "%");
}
String beginTimeStr = bpmTaskQueryParam.getSearchBeginTime();
String endTimeStr = bpmTaskQueryParam.getSearchEndTime();
LocalDateTime beginTime = LocalDateTimeUtil.parse(beginTimeStr, DatePattern.NORM_DATE_PATTERN);
LocalDateTime endTime = PubUtils.endTimeToLocalDateTime(endTimeStr);
taskQuery.taskCreatedBefore(DateUtils.of(endTime));
taskQuery.taskCreatedAfter(DateUtils.of(beginTime));
// 执行查询
long count = taskQuery.count();
if (count == 0) {
return PageResult.empty();
}
int offset = PageFactory.getPageSize(bpmTaskQueryParam) * (PageFactory.getPageNum(bpmTaskQueryParam) - 1);
List<HistoricTaskInstance> tasks = taskQuery.listPage(offset, PageFactory.getPageSize(bpmTaskQueryParam));
return new PageResult<>(tasks, count);
}
@Override
public List<Task> getTasksByProcessInstanceIds(List<String> processInstanceIds) {
if (CollectionUtil.isEmpty(processInstanceIds)) {
return Collections.emptyList();
}
return taskService.createTaskQuery().processInstanceIdIn(processInstanceIds).list();
}
@Override
public List<HistoricTaskInstance> getTaskListByProcessInstanceId(String processInstanceId) {
List<HistoricTaskInstance> tasks = historyService.createHistoricTaskInstanceQuery()
.includeTaskLocalVariables()
.processInstanceId(processInstanceId)
.orderByHistoricTaskInstanceStartTime().desc() // 创建时间倒序
.list();
if (CollectionUtil.isEmpty(tasks)) {
return Collections.emptyList();
}
return tasks;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void approveTask(String userId, BpmTaskApproveParam bpmTaskApproveParam) {
// 1.1 校验任务存在
Task task = validateTask(userId, bpmTaskApproveParam.getId());
// 1.2 校验流程实例存在
ProcessInstance instance = processInstanceService.getProcessInstance(task.getProcessInstanceId());
if (instance == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_NOT_EXISTS);
}
// 2. 抄送用户
if (CollectionUtil.isNotEmpty(bpmTaskApproveParam.getCopyUserIds())) {
processInstanceCopyService.createProcessInstanceCopy(bpmTaskApproveParam.getCopyUserIds(), bpmTaskApproveParam.getId());
}
// 情况一：被委派的任务，不调用 complete 去完成任务
if (DelegationState.PENDING.equals(task.getDelegationState())) {
approveDelegateTask(bpmTaskApproveParam, task);
return;
}
// 情况二：审批有【后】加签的任务
if (BpmTaskSignTypeEnum.AFTER.getType().equals(task.getScopeType())) {
approveAfterSignTask(task, bpmTaskApproveParam);
return;
}
// 情况三：审批普通的任务。大多数情况下，都是这样
// 3.1 更新 task 状态、原因
updateTaskStatusAndReason(task.getId(), BpmTaskStatusEnum.APPROVE.getStatus(), bpmTaskApproveParam.getReason());
// 3.2 添加评论
taskService.addComment(task.getId(), task.getProcessInstanceId(), BpmCommentTypeEnum.APPROVE.getType(),
BpmCommentTypeEnum.APPROVE.formatComment(bpmTaskApproveParam.getReason()));
// 3.3 调用 BPM complete 去完成任务
// 其中，variables 是存储动态表单到 local 任务级别。过滤一下，避免 ProcessInstance 系统级的变量被占用
if (CollectionUtil.isNotEmpty(bpmTaskApproveParam.getVariables())) {
Map<String, Object> variables = FlowableUtils.filterTaskFormVariable(bpmTaskApproveParam.getVariables());
taskService.complete(task.getId(), variables, true);
} else {
taskService.complete(task.getId());
}
// 【加签专属】处理加签任务
handleParentTaskIfSign(task.getParentTaskId());
}
/**
* 审批通过存在“后加签”的任务。
* <p>
* 注意：该任务不能马上完成，需要一个中间状态（APPROVING），并激活剩余所有子任务（PROCESS）为可审批处理
* 如果马上完成，则会触发下一个任务，甚至如果没有下一个任务则流程实例就直接结束了！
*
* @param task 当前任务
* @param bpmTaskApproveParam 前端请求参数
*/
private void approveAfterSignTask(Task task, BpmTaskApproveParam bpmTaskApproveParam) {
// 更新父 task 状态 + 原因
updateTaskStatusAndReason(task.getId(), BpmTaskStatusEnum.APPROVING.getStatus(), bpmTaskApproveParam.getReason());
// 2. 激活子任务
List<Task> childrenTaskList = getTaskListByParentTaskId(task.getId());
for (Task childrenTask : childrenTaskList) {
taskService.resolveTask(childrenTask.getId());
// 更新子 task 状态
updateTaskStatus(childrenTask.getId(), BpmTaskStatusEnum.RUNNING.getStatus());
}
}
/**
* 如果父任务是有前后【加签】的任务，如果它【加签】出来的子任务都被处理，需要处理父任务：
* <p>
* 1. 如果是【向前】加签，则需要重新激活父任务，让它可以被审批
* 2. 如果是【向后】加签，则需要完成父任务，让它完成审批
*
* @param parentTaskId 父任务编号
*/
private void handleParentTaskIfSign(String parentTaskId) {
if (StrUtil.isBlank(parentTaskId)) {
return;
}
// 1.1 判断是否还有子任务。如果没有，就不处理
Long childrenTaskCount = getTaskCountByParentTaskId(parentTaskId);
if (childrenTaskCount > 0) {
return;
}
// 1.2 只处理加签的父任务
Task parentTask = validateTaskExist(parentTaskId);
String scopeType = parentTask.getScopeType();
if (BpmTaskSignTypeEnum.of(scopeType) == null) {
return;
}
// 2. 子任务已处理完成，清空 scopeType 字段，修改 parentTask 信息，方便后续可以继续向前后向后加签
TaskEntityImpl parentTaskImpl = (TaskEntityImpl) parentTask;
parentTaskImpl.setScopeType(null);
taskService.saveTask(parentTaskImpl);
// 3.1 情况一：处理向【向前】加签
if (BpmTaskSignTypeEnum.BEFORE.getType().equals(scopeType)) {
// 3.1.1 owner 重新赋值给父任务的 assignee，这样它就可以被审批
taskService.resolveTask(parentTaskId);
// 3.1.2 更新流程任务 status
updateTaskStatus(parentTaskId, BpmTaskStatusEnum.RUNNING.getStatus());
// 3.2 情况二：处理向【向后】加签
} else if (BpmTaskSignTypeEnum.AFTER.getType().equals(scopeType)) {
// 只有 parentTask 处于 APPROVING 的情况下，才可以继续 complete 完成
// 否则，一个未审批的 parentTask 任务，在加签出来的任务都被减签的情况下，就直接完成审批，这样会存在问题
Integer status = (Integer) parentTask.getTaskLocalVariables().get(BpmConstants.TASK_VARIABLE_STATUS);
if (ObjectUtil.notEqual(status, BpmTaskStatusEnum.APPROVING.getStatus())) {
return;
}
// 3.2.2 完成自己（因为它已经没有子任务，所以也可以完成）
updateTaskStatus(parentTaskId, BpmTaskStatusEnum.APPROVE.getStatus());
taskService.complete(parentTaskId);
}
// 4. 递归处理父任务
handleParentTaskIfSign(parentTask.getParentTaskId());
}
/**
* 审批被委派的任务
*
* @param bpmTaskApproveParam 前端请求参数，包含当前任务ID，审批意见等
* @param task 当前被审批的任务
*/
private void approveDelegateTask(BpmTaskApproveParam bpmTaskApproveParam, Task task) {
// 1. 添加审批意见
UserVO currentUser = adminUserApi.getUserById(RequestUtil.getUserIndex()).getData();
UserVO ownerUser = adminUserApi.getUserById(task.getOwner()).getData(); // 发起委托的用户
Assert.notNull(ownerUser, "委派任务找不到原审批人，需要检查数据");
taskService.addComment(bpmTaskApproveParam.getId(), task.getProcessInstanceId(), BpmCommentTypeEnum.DELEGATE_END.getType(),
BpmCommentTypeEnum.DELEGATE_END.formatComment(currentUser.getName(), ownerUser.getName(), bpmTaskApproveParam.getReason()));
// 2.1 调用 resolveTask 完成任务。
// 底层调用 TaskHelper.changeTaskAssignee(task, task.getOwner())：将 owner 设置为 assignee
taskService.resolveTask(task.getId());
// 2.2 更新 task 状态 + 原因
updateTaskStatusAndReason(task.getId(), BpmTaskStatusEnum.RUNNING.getStatus(), bpmTaskApproveParam.getReason());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void rejectTask(String userId, BpmTaskRejectParam bpmTaskRejectParam) {
// 1.1 校验任务存在
Task task = validateTask(userId, bpmTaskRejectParam.getId());
// 1.2 校验流程实例存在
ProcessInstance instance = processInstanceService.getProcessInstance(task.getProcessInstanceId());
if (instance == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_NOT_EXISTS);
}
// 2.1 更新流程实例为不通过
updateTaskStatusAndReason(task.getId(), BpmTaskStatusEnum.REJECT.getStatus(), bpmTaskRejectParam.getReason());
// 2.2 添加评论
taskService.addComment(task.getId(), task.getProcessInstanceId(), BpmCommentTypeEnum.REJECT.getType(),
BpmCommentTypeEnum.REJECT.formatComment(bpmTaskRejectParam.getReason()));
// 3. 更新流程实例，审批不通过！
processInstanceService.updateProcessInstanceReject(instance.getProcessInstanceId(), bpmTaskRejectParam.getReason());
}
/**
* 更新流程任务的 status 状态
*
* @param id 任务编号
* @param status 状态
*/
private void updateTaskStatus(String id, Integer status) {
taskService.setVariableLocal(id, BpmConstants.TASK_VARIABLE_STATUS, status);
}
/**
* 更新流程任务的 status 状态、reason 理由
*
* @param id 任务编号
* @param status 状态
* @param reason 理由（审批通过、审批不通过的理由）
*/
private void updateTaskStatusAndReason(String id, Integer status, String reason) {
updateTaskStatus(id, status);
taskService.setVariableLocal(id, BpmConstants.TASK_VARIABLE_REASON, reason);
}
/**
* 校验任务是否存在，并且是否是分配给自己的任务
*
* @param userId 用户 id
* @param taskId task id
*/
private Task validateTask(String userId, String taskId) {
Task task = validateTaskExist(taskId);
if (!Objects.equals(userId, task.getAssignee())) {
throw new BusinessException(BpmResponseEnum.TASK_OPERATE_FAIL_ASSIGN_NOT_SELF);
}
return task;
}
@Override
public void updateTaskStatusWhenCreated(Task task) {
Integer status = (Integer) task.getTaskLocalVariables().get(BpmConstants.TASK_VARIABLE_STATUS);
if (status != null) {
log.error("[updateTaskStatusWhenCreated][taskId({}) 已经有状态({})]", task.getId(), status);
return;
}
updateTaskStatus(task.getId(), BpmTaskStatusEnum.RUNNING.getStatus());
}
@Override
public void updateTaskStatusWhenCanceled(String taskId) {
Task task = getTask(taskId);
// 1. 可能只是活动，不是任务，所以查询不到
if (task == null) {
log.error("[updateTaskStatusWhenCanceled][taskId({}) 任务不存在]", taskId);
return;
}
// 2. 更新 task 状态 + 原因
Integer status = (Integer) task.getTaskLocalVariables().get(BpmConstants.TASK_VARIABLE_STATUS);
if (BpmTaskStatusEnum.isEndStatus(status)) {
log.error("[updateTaskStatusWhenCanceled][taskId({}) 处于结果({})，无需进行更新]", taskId, status);
return;
}
updateTaskStatusAndReason(taskId, BpmTaskStatusEnum.CANCEL.getStatus(), BpmDeleteReasonEnum.CANCEL_BY_SYSTEM.getReason());
// 补充说明：由于 Task 被删除成 HistoricTask 后，无法通过 taskService.addComment 添加理由，所以无法存储具体的取消理由
}
@Override
public void updateTaskExtAssign(Task task) {
// 发送通知。在事务提交时，批量执行操作，所以直接查询会无法查询到 ProcessInstance，所以这里是通过监听事务的提交来实现。
TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
@Override
public void afterCommit() {
if (StrUtil.isEmpty(task.getAssignee())) {
return;
}
ProcessInstance processInstance = processInstanceService.getProcessInstance(task.getProcessInstanceId());
UserVO startUser = adminUserApi.getUserById(processInstance.getStartUserId()).getData();
//发送消息
// messageService.sendMessageWhenTaskAssigned(BpmTaskConvert.INSTANCE.convert(processInstance, startUser, task));
}
});
}
private Task validateTaskExist(String id) {
Task task = getTask(id);
if (task == null) {
throw new BusinessException(BpmResponseEnum.TASK_NOT_EXISTS);
}
return task;
}
@Override
public Task getTask(String id) {
return taskService.createTaskQuery().taskId(id).includeTaskLocalVariables().singleResult();
}
//
// private HistoricTaskInstance getHistoricTask(String id) {
// return historyService.createHistoricTaskInstanceQuery().taskId(id).includeTaskLocalVariables().singleResult();
// }
//
@Override
public List<UserTask> getUserTaskListByReturn(String id) {
// 1.1 校验当前任务 task 存在
Task task = validateTaskExist(id);
// 1.2 根据流程定义获取流程模型信息
BpmnModel bpmnModel = bpmModelService.getBpmnModelByDefinitionId(task.getProcessDefinitionId());
FlowElement source = BpmnModelUtils.getFlowElementById(bpmnModel, task.getTaskDefinitionKey());
if (source == null) {
throw new BusinessException(BpmResponseEnum.TASK_NOT_EXISTS);
}
// 2.1 查询该任务的前置任务节点的 key 集合
List<UserTask> previousUserList = BpmnModelUtils.getPreviousUserTaskList(source, null, null);
if (CollectionUtil.isEmpty(previousUserList)) {
return Collections.emptyList();
}
// 2.2 过滤：只有串行可到达的节点，才可以回退。类似非串行、子流程无法退回
previousUserList.removeIf(userTask -> !BpmnModelUtils.isSequentialReachable(source, userTask, null));
return previousUserList;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void returnTask(String userId, BpmTaskReturnParam bpmTaskReturnParam) {
// 1.1 当前任务 task
Task task = validateTask(userId, bpmTaskReturnParam.getId());
if (task.isSuspended()) {
throw new BusinessException(BpmResponseEnum.TASK_IS_PENDING);
}
// 1.2 校验源头和目标节点的关系，并返回目标元素
FlowElement targetElement = validateTargetTaskCanReturn(task.getTaskDefinitionKey(),
bpmTaskReturnParam.getTargetTaskDefinitionKey(), task.getProcessDefinitionId());
// 2. 调用 Flowable 框架的回退逻辑
returnTask(task, targetElement, bpmTaskReturnParam);
}
/**
* 回退流程节点时，校验目标任务节点是否可回退
*
* @param sourceKey 当前任务节点 Key
* @param targetKey 目标任务节点 key
* @param processDefinitionId 当前流程定义 ID
* @return 目标任务节点元素
*/
private FlowElement validateTargetTaskCanReturn(String sourceKey, String targetKey, String processDefinitionId) {
// 1.1 获取流程模型信息
BpmnModel bpmnModel = bpmModelService.getBpmnModelByDefinitionId(processDefinitionId);
// 1.3 获取当前任务节点元素
FlowElement source = BpmnModelUtils.getFlowElementById(bpmnModel, sourceKey);
// 1.3 获取跳转的节点元素
FlowElement target = BpmnModelUtils.getFlowElementById(bpmnModel, targetKey);
if (target == null) {
throw new BusinessException(BpmResponseEnum.TASK_TARGET_NODE_NOT_EXISTS);
}
// 2.2 只有串行可到达的节点，才可以回退。类似非串行、子流程无法退回
if (!BpmnModelUtils.isSequentialReachable(source, target, null)) {
throw new BusinessException(BpmResponseEnum.TASK_RETURN_FAIL_SOURCE_TARGET_ERROR);
}
return target;
}
/**
* 执行回退逻辑
*
* @param currentTask 当前回退的任务
* @param targetElement 需要回退到的目标任务
* @param bpmTaskReturnParam 前端参数封装
*/
public void returnTask(Task currentTask, FlowElement targetElement, BpmTaskReturnParam bpmTaskReturnParam) {
// 1. 获得所有需要回撤的任务 taskDefinitionKey，用于稍后的 moveActivityIdsToSingleActivityId 回撤
// 1.1 获取所有正常进行的任务节点 Key
List<Task> taskList = taskService.createTaskQuery().processInstanceId(currentTask.getProcessInstanceId()).list();
List<String> runTaskKeyList = convertList(taskList, Task::getTaskDefinitionKey);
// 1.2 通过 targetElement 的出口连线，计算在 runTaskKeyList 有哪些 key 需要被撤回
// 为什么不直接使用 runTaskKeyList 呢？因为可能存在多个审批分支，例如说：A -> B -> C 和 D -> F，而只要 C 撤回到 A，需要排除掉 F
List<UserTask> returnUserTaskList = BpmnModelUtils.iteratorFindChildUserTasks(targetElement, runTaskKeyList, null, null);
List<String> returnTaskKeyList = convertList(returnUserTaskList, UserTask::getId);
// 2. 给当前要被回退的 task 数组，设置回退意见
taskList.forEach(task -> {
// 需要排除掉，不需要设置回退意见的任务
if (!returnTaskKeyList.contains(task.getTaskDefinitionKey())) {
return;
}
// 2.1 添加评论
taskService.addComment(task.getId(), currentTask.getProcessInstanceId(), BpmCommentTypeEnum.RETURN.getType(),
BpmCommentTypeEnum.RETURN.formatComment(bpmTaskReturnParam.getReason()));
// 2.2 更新 task 状态 + 原因
updateTaskStatusAndReason(task.getId(), BpmTaskStatusEnum.RETURN.getStatus(), bpmTaskReturnParam.getReason());
});
// 3. 执行驳回
runtimeService.createChangeActivityStateBuilder()
.processInstanceId(currentTask.getProcessInstanceId())
.moveActivityIdsToSingleActivityId(returnTaskKeyList, // 当前要跳转的节点列表( 1 或多)
bpmTaskReturnParam.getTargetTaskDefinitionKey()) // targetKey 跳转到的节点(1)
.changeState();
}
@Override
@Transactional(rollbackFor = Exception.class)
public void delegateTask(String userId, BpmTaskDelegateParam reqVO) {
String taskId = reqVO.getId();
// 1.1 校验任务
Task task = validateTask(userId, reqVO.getId());
if (task.getAssignee().equals(reqVO.getDelegateUserId())) { // 校验当前审批人和被委派人不是同一人
throw new BusinessException(BpmResponseEnum.TASK_DELEGATE_FAIL_USER_REPEAT);
}
// 1.2 校验目标用户存在
UserVO delegateUser = adminUserApi.getUserById(reqVO.getDelegateUserId()).getData();
if (delegateUser == null) {
throw new BusinessException(BpmResponseEnum.TASK_DELEGATE_FAIL_USER_NOT_EXISTS);
}
// 2. 添加委托意见
UserVO currentUser = adminUserApi.getUserById(userId).getData();
taskService.addComment(taskId, task.getProcessInstanceId(), BpmCommentTypeEnum.DELEGATE_START.getType(),
BpmCommentTypeEnum.DELEGATE_START.formatComment(currentUser.getName(), delegateUser.getName(), reqVO.getReason()));
// 3.1 设置任务所有人 (owner) 为原任务的处理人 (assignee)
taskService.setOwner(taskId, task.getAssignee());
// 3.2 执行委派，将任务委派给 delegateUser
taskService.delegateTask(taskId, reqVO.getDelegateUserId());
// 3.3 更新 task 状态。
// 为什么不更新原因？因为原因目前主要给审批通过、不通过时使用
updateTaskStatus(taskId, BpmTaskStatusEnum.DELEGATE.getStatus());
}
@Override
public void transferTask(String userId, BpmTaskTransferParam reqVO) {
String taskId = reqVO.getId();
// 1.1 校验任务
Task task = validateTask(userId, reqVO.getId());
if (task.getAssignee().equals(reqVO.getAssigneeUserId())) { // 校验当前审批人和被转派人不是同一人
throw new BusinessException(BpmResponseEnum.TASK_DELEGATE_FAIL_USER_NOT_EXISTS);
}
// 1.2 校验目标用户存在
UserVO assigneeUser = adminUserApi.getUserById(reqVO.getAssigneeUserId()).getData();
if (assigneeUser == null) {
throw new BusinessException(BpmResponseEnum.TASK_TRANSFER_FAIL_USER_NOT_EXISTS);
}
// 2. 添加委托意见
UserVO currentUser = adminUserApi.getUserById(userId).getData();
taskService.addComment(taskId, task.getProcessInstanceId(), BpmCommentTypeEnum.TRANSFER.getType(),
BpmCommentTypeEnum.TRANSFER.formatComment(currentUser.getName(), assigneeUser.getName(), reqVO.getReason()));
// 3.1 设置任务所有人 (owner) 为原任务的处理人 (assignee)
taskService.setOwner(taskId, task.getAssignee());
// 3.2 执行转派（审批人），将任务转派给 assigneeUser
// 委托（ delegate）和转派（transfer）的差别，就在这块的调用！！！！
taskService.setAssignee(taskId, reqVO.getAssigneeUserId().toString());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void createSignTask(String userId, BpmTaskSignCreateParam reqVO) {
// 1. 获取和校验任务
TaskEntityImpl taskEntity = validateTaskCanCreateSign(userId, reqVO);
List<UserVO> userList = adminUserApi.getUserVOByIdList(reqVO.getUserIds()).getData();
if (CollUtil.isEmpty(userList)) {
throw new BusinessException(BpmResponseEnum.TASK_SIGN_CREATE_USER_NOT_EXIST);
}
// 2. 处理当前任务
// 2.1 开启计数功能，主要用于为了让表 ACT_RU_TASK 中的 SUB_TASK_COUNT_ 字段记录下总共有多少子任务，后续可能有用
taskEntity.setCountEnabled(true);
// 2.2 向前加签，设置 owner，置空 assign。等子任务都完成后，再调用 resolveTask 重新将 owner 设置为 assign
// 原因是：不能和向前加签的子任务一起审批，需要等前面的子任务都完成才能审批
if (reqVO.getType().equals(BpmTaskSignTypeEnum.BEFORE.getType())) {
taskEntity.setOwner(taskEntity.getAssignee());
taskEntity.setAssignee(null);
}
// 2.4 记录加签方式，完成任务时需要用到判断
taskEntity.setScopeType(reqVO.getType());
// 2.5 保存当前任务修改后的值
taskService.saveTask(taskEntity);
// 2.6 更新 task 状态为 WAIT，只有在向前加签的时候
if (reqVO.getType().equals(BpmTaskSignTypeEnum.BEFORE.getType())) {
updateTaskStatus(taskEntity.getId(), BpmTaskStatusEnum.WAIT.getStatus());
}
// 3. 创建加签任务
createSignTaskList(convertList(reqVO.getUserIds(), String::valueOf), taskEntity);
// 4. 记录加签的评论到 task 任务
UserVO currentUser = adminUserApi.getUserById(userId).getData();
String comment = StrUtil.format(BpmCommentTypeEnum.ADD_SIGN.getComment(),
currentUser.getName(), BpmTaskSignTypeEnum.nameOfType(reqVO.getType()),
String.join(",", convertList(userList, UserVO::getName)), reqVO.getReason());
taskService.addComment(reqVO.getId(), taskEntity.getProcessInstanceId(), BpmCommentTypeEnum.ADD_SIGN.getType(), comment);
}
/**
* 校验任务是否可以加签，主要校验加签类型是否一致：
* <p>
* 1. 如果存在“向前加签”的任务，则不能“向后加签”
* 2. 如果存在“向后加签”的任务，则不能“向前加签”
*
* @param userId 当前用户 ID
* @param reqVO 请求参数，包含任务 ID 和加签类型
* @return 当前任务
*/
private TaskEntityImpl validateTaskCanCreateSign(String userId, BpmTaskSignCreateParam reqVO) {
TaskEntityImpl taskEntity = (TaskEntityImpl) validateTask(userId, reqVO.getId());
// 向前加签和向后加签不能同时存在
if (taskEntity.getScopeType() != null
&& ObjectUtil.notEqual(taskEntity.getScopeType(), reqVO.getType())) {
throw new BusinessException("任务加签：当前任务已经" + BpmTaskSignTypeEnum.nameOfType(taskEntity.getScopeType()) + "，不能" + BpmTaskSignTypeEnum.nameOfType(reqVO.getType()));
}
// 同一个 key 的任务，审批人不重复
List<Task> taskList = taskService.createTaskQuery().processInstanceId(taskEntity.getProcessInstanceId())
.taskDefinitionKey(taskEntity.getTaskDefinitionKey()).list();
List<String> currentAssigneeList = convertListByFlatMap(taskList, task -> // 需要考虑 owner 的情况，因为向后加签时，它暂时没 assignee 而是 owner
Stream.of(task.getAssignee(), task.getOwner()));
if (CollUtil.containsAny(currentAssigneeList, reqVO.getUserIds())) {
List<UserVO> userList = adminUserApi.getUserVOByIdList((List<String>) CollUtil.intersection(currentAssigneeList, reqVO.getUserIds())).getData();
throw new BusinessException("任务加签失败，加签人与现有审批人[" + String.join(",", convertList(userList, UserVO::getName)) + "]重复");
}
return taskEntity;
}
/**
* 创建加签子任务
*
* @param userIds 被加签的用户 ID
* @param taskEntity 被加签的任务
*/
private void createSignTaskList(List<String> userIds, TaskEntityImpl taskEntity) {
if (CollUtil.isEmpty(userIds)) {
return;
}
// 创建加签人的新任务，全部基于 taskEntity 为父任务来创建
for (String addSignId : userIds) {
if (StrUtil.isBlank(addSignId)) {
continue;
}
createSignTask(taskEntity, addSignId);
}
}
/**
* 创建加签子任务
*
* @param parentTask 父任务
* @param assignee 子任务的执行人
*/
private void createSignTask(TaskEntityImpl parentTask, String assignee) {
// 1. 生成子任务
TaskEntityImpl task = (TaskEntityImpl) taskService.newTask(IdUtil.fastSimpleUUID());
BpmTaskConvert.INSTANCE.copyTo(parentTask, task);
// 2.1 向前加签，设置审批人
if (BpmTaskSignTypeEnum.BEFORE.getType().equals(parentTask.getScopeType())) {
task.setAssignee(assignee);
// 2.2 向后加签，设置 owner 不设置 assignee 是因为不能同时审批，需要等父任务完成
} else {
task.setOwner(assignee);
}
// 2.3 保存子任务
taskService.saveTask(task);
// 3. 向后前签，设置子任务的状态为 WAIT，因为需要等父任务审批完
if (BpmTaskSignTypeEnum.AFTER.getType().equals(parentTask.getScopeType())) {
updateTaskStatus(task.getId(), BpmTaskStatusEnum.WAIT.getStatus());
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteSignTask(String userId, BpmTaskSignDeleteParam reqVO) {
// 1.1 校验 task 可以被减签
Task task = validateTaskCanSignDelete(reqVO.getId());
// 1.2 校验取消人存在
UserVO cancelUser = null;
if (StrUtil.isNotBlank(task.getAssignee())) {
cancelUser = adminUserApi.getUserById(task.getAssignee()).getData();
}
if (cancelUser == null && StrUtil.isNotBlank(task.getOwner())) {
cancelUser = adminUserApi.getUserById(task.getOwner()).getData();
}
Assert.notNull(cancelUser, "任务中没有所有者和审批人，数据错误");
// 2.1 获得子任务列表，包括子任务的子任务
List<Task> childTaskList = getAllChildTaskList(task);
childTaskList.add(task);
// 2.2 更新子任务为已取消
String cancelReason = StrUtil.format("任务被取消，原因：由于[{}]操作[减签]，", cancelUser.getName());
childTaskList.forEach(childTask -> updateTaskStatusAndReason(childTask.getId(), BpmTaskStatusEnum.CANCEL.getStatus(), cancelReason));
// 2.3 删除任务和所有子任务
taskService.deleteTasks(convertList(childTaskList, Task::getId));
// 3. 记录日志到父任务中。先记录日志是因为，通过 handleParentTask 方法之后，任务可能被完成了，并且不存在了，会报异常，所以先记录
UserVO user = adminUserApi.getUserById(userId).getData();
taskService.addComment(task.getParentTaskId(), task.getProcessInstanceId(), BpmCommentTypeEnum.SUB_SIGN.getType(),
StrUtil.format(BpmCommentTypeEnum.SUB_SIGN.getComment(), user.getName(), cancelUser.getName()));
// 4. 处理当前任务的父任务
handleParentTaskIfSign(task.getParentTaskId());
}
/**
* 校验任务是否能被减签
*
* @param id 任务编号
* @return 任务信息
*/
private Task validateTaskCanSignDelete(String id) {
Task task = validateTaskExist(id);
if (task.getParentTaskId() == null) {
throw new BusinessException(BpmResponseEnum.TASK_SIGN_DELETE_NO_PARENT);
}
Task parentTask = getTask(task.getParentTaskId());
if (parentTask == null) {
throw new BusinessException(BpmResponseEnum.TASK_SIGN_DELETE_NO_PARENT);
}
if (BpmTaskSignTypeEnum.of(parentTask.getScopeType()) == null) {
throw new BusinessException(BpmResponseEnum.TASK_SIGN_DELETE_NO_PARENT);
}
return task;
}
/**
* 获得所有子任务列表
*
* @param parentTask 父任务
* @return 所有子任务列表
*/
private List<Task> getAllChildTaskList(Task parentTask) {
List<Task> result = new ArrayList<>();
// 1. 递归获取子级
Stack<Task> stack = new Stack<>();
stack.push(parentTask);
// 2. 递归遍历
for (int i = 0; i < Short.MAX_VALUE; i++) {
if (stack.isEmpty()) {
break;
}
// 2.1 获取子任务们
Task task = stack.pop();
List<Task> childTaskList = getTaskListByParentTaskId(task.getId());
// 2.2 如果非空，则添加到 stack 进一步递归
if (CollUtil.isNotEmpty(childTaskList)) {
stack.addAll(childTaskList);
result.addAll(childTaskList);
}
}
return result;
}
@Override
public List<Task> getTaskListByParentTaskId(String parentTaskId) {
String tableName = managementService.getTableName(TaskEntity.class);
// taskService.createTaskQuery() 没有 parentId 参数，所以写 sql 查询
String sql = "select ID_,NAME_,OWNER_,ASSIGNEE_ from " + tableName + " where PARENT_TASK_ID_=#{parentTaskId}";
return taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).list();
}
/**
* 获取子任务个数
*
* @param parentTaskId 父任务 ID
* @return 剩余子任务个数
*/
private Long getTaskCountByParentTaskId(String parentTaskId) {
String tableName = managementService.getTableName(TaskEntity.class);
String sql = "SELECT COUNT(1) from " + tableName + " WHERE PARENT_TASK_ID_=#{parentTaskId}";
return taskService.createNativeTaskQuery().sql(sql).parameter("parentTaskId", parentTaskId).count();
}
//
// @Override
// public Map<String, String> getTaskNameByTaskIds(Collection<String> taskIds) {
// if (CollUtil.isEmpty(taskIds)) {
// return Collections.emptyMap();
// }
// List<Task> tasks = taskService.createTaskQuery().taskIds(taskIds).list();
// return convertMap(tasks, Task::getId, Task::getName);
// }
}

82
pqs-bpm/bpm-boot/src/main/java/com/njcn/bpm/service/task/impl/ProcessInstanceCopyServiceImpl.java Normal file
View File

@@ -0,0 +1,82 @@
package com.njcn.bpm.service.task.impl;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.bpm.enums.BpmResponseEnum;
import com.njcn.bpm.mapper.task.ProcessInstanceCopyMapper;
import com.njcn.bpm.pojo.po.task.ProcessInstanceCopy;
import com.njcn.bpm.service.IBpmProcessDefinitionService;
import com.njcn.bpm.service.task.IBpmProcessInstanceService;
import com.njcn.bpm.service.task.IBpmTaskService;
import com.njcn.bpm.service.task.IProcessInstanceCopyService;
import com.njcn.common.pojo.exception.BusinessException;
import org.flowable.engine.repository.ProcessDefinition;
import org.flowable.engine.runtime.ProcessInstance;
import org.flowable.task.api.Task;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* BPM 流程实例抄送表 服务实现类
* </p>
*
* @author hongawen
* @since 2024-05-10
*/
@Service
public class ProcessInstanceCopyServiceImpl extends ServiceImpl<ProcessInstanceCopyMapper, ProcessInstanceCopy> implements IProcessInstanceCopyService {
@Resource
@Lazy // 延迟加载，避免循环依赖
private IBpmTaskService taskService;
@Resource
@Lazy // 延迟加载，避免循环依赖
private IBpmProcessInstanceService processInstanceService;
@Resource
@Lazy // 延迟加载，避免循环依赖
private IBpmProcessDefinitionService processDefinitionService;
@Override
public void createProcessInstanceCopy(Collection<String> userIds, String taskId) {
// 1.1 校验任务存在
Task task = taskService.getTask(taskId);
if (ObjectUtil.isNull(task)) {
throw new BusinessException(BpmResponseEnum.TASK_NOT_EXISTS);
}
// 1.2 校验流程实例存在
String processInstanceId = task.getProcessInstanceId();
ProcessInstance processInstance = processInstanceService.getProcessInstance(processInstanceId);
if (processInstance == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_INSTANCE_NOT_EXISTS);
}
// 1.3 校验流程定义存在
ProcessDefinition processDefinition = processDefinitionService.getProcessDefinition(
processInstance.getProcessDefinitionId());
if (processDefinition == null) {
throw new BusinessException(BpmResponseEnum.PROCESS_DEFINITION_NOT_EXISTS);
}
// 2. 创建抄送流程
List<ProcessInstanceCopy> copyList = userIds.stream().map(userId -> {
ProcessInstanceCopy processInstanceCopy = new ProcessInstanceCopy();
processInstanceCopy.setUserId(userId);
processInstanceCopy.setStartUserId(processInstance.getStartUserId());
processInstanceCopy.setProcessInstanceId(processInstanceId);
processInstanceCopy.setProcessInstanceName(processInstance.getName());
processInstanceCopy.setCategory(processDefinition.getCategory());
processInstanceCopy.setTaskId(taskId);
processInstanceCopy.setTaskName(task.getName());
return processInstanceCopy;
}).collect(Collectors.toList());
this.saveBatch(copyList);
}
}