From 34981c30a78e8bbd7791131059a9210f9928b62c Mon Sep 17 00:00:00 2001
From: 刘光辉 <347230014@qq.com>
Date: 星期四, 17 九月 2026 09:24:09 +0800
Subject: [PATCH] Merge remote-tracking branch 'origin/master' into master
---
jnpf-flowable/jnpf-flowable-biz/src/main/java/jnpf/flowable/util/TaskUtil.java | 233 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 233 insertions(+), 0 deletions(-)
diff --git a/jnpf-flowable/jnpf-flowable-biz/src/main/java/jnpf/flowable/util/TaskUtil.java b/jnpf-flowable/jnpf-flowable-biz/src/main/java/jnpf/flowable/util/TaskUtil.java
new file mode 100644
index 0000000..2c96c08
--- /dev/null
+++ b/jnpf-flowable/jnpf-flowable-biz/src/main/java/jnpf/flowable/util/TaskUtil.java
@@ -0,0 +1,233 @@
+package jnpf.flowable.util;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.google.common.collect.ImmutableList;
+import jnpf.constant.MsgCode;
+import jnpf.exception.WorkFlowException;
+import jnpf.flowable.entity.*;
+import jnpf.flowable.enums.OperatorStateEnum;
+import jnpf.flowable.enums.TaskStatusEnum;
+import jnpf.flowable.mapper.*;
+import jnpf.flowable.model.util.FlowNature;
+import jnpf.util.StringUtil;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Component
+@RequiredArgsConstructor
+public class TaskUtil {
+
+
+ private final TaskMapper taskMapper;
+
+ private final LaunchUserMapper launchUserMapper;
+
+ private final CandidatesMapper candidatesMapper;
+
+ private final OperatorMapper operatorMapper;
+
+ private final RecordMapper recordMapper;
+
+ private final CirculateMapper circulateMapper;
+
+ private final CommentMapper commentMapper;
+
+ private final RejectDataMapper rejectDataMapper;
+
+ private final NodeRecordMapper nodeRecordMapper;
+
+ private final TaskLineMapper taskLineMapper;
+
+ private final RevokeMapper revokeMapper;
+
+ private final TriggerTaskMapper triggerTaskMapper;
+
+ private final TriggerRecordMapper triggerRecordMapper;
+
+ private final EventLogMapper eventLogMapper;
+
+ private final TriggerLaunchflowMapper triggerLaunchflowMapper;
+
+
+ public List<TaskEntity> delete(List<String> ids, boolean isBatch) throws WorkFlowException {
+ List<TaskEntity> taskList = taskMapper.getOrderStaList(ids);
+ List<TaskEntity> taskStatus = taskList.stream()
+ .filter(t -> TaskStatusEnum.PAUSED.getCode().equals(t.getStatus())).collect(Collectors.toList());
+ if (!taskStatus.isEmpty()) {
+ throw new WorkFlowException(isBatch ? taskStatus.get(0).getFullName() + MsgCode.WF113.get() : MsgCode.WF114.get());
+ }
+ if (!isBatch) {
+ List<Integer> status = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.RECALL.getCode());
+ List<TaskEntity> taskStateList = taskList.stream().filter(e -> !status.contains(e.getStatus())).collect(Collectors.toList());
+ if (!taskStateList.isEmpty()) {
+ throw new WorkFlowException(MsgCode.WF063.get());
+ }
+ }
+
+ List<TaskEntity> child = taskList.stream()
+ .filter(t -> StringUtil.isNotEmpty(t.getParentId()) && !FlowNature.PARENT_ID.equals(t.getParentId())).collect(Collectors.toList());
+ if (!child.isEmpty()) {
+ throw new WorkFlowException(child.get(0).getFullName() + MsgCode.WF021.get());
+ }
+
+ for (TaskEntity entity : taskList) {
+ List<TriggerLaunchflowEntity> triggerList = triggerLaunchflowMapper.getTaskIds(entity.getId());
+ if (!triggerList.isEmpty()) {
+ throw new WorkFlowException(entity.getFullName() + MsgCode.WF157.get());
+ }
+ }
+ delete(ids);
+ return taskList;
+ }
+
+ public void delete(List<String> idList) {
+ List<String> idAll = new ArrayList<>();
+ taskMapper.deleTaskAll(idList, idAll);
+ List<String> revokeTaskIds = revokeMapper.getByTaskId(idAll);
+ idAll.addAll(revokeTaskIds);
+ if (!idAll.isEmpty()) {
+ QueryWrapper<TaskEntity> task = new QueryWrapper<>();
+ task.lambda().in(TaskEntity::getId, idAll);
+ taskMapper.deleteByIds(taskMapper.selectList(task));
+ // 鍊欓�変汉
+ QueryWrapper<CandidatesEntity> candidates = new QueryWrapper<>();
+ candidates.lambda().select(CandidatesEntity::getId);
+ candidates.lambda().in(CandidatesEntity::getTaskId, idAll);
+ candidatesMapper.deleteByIds(candidatesMapper.selectList(candidates));
+ // 鍙戣捣浜�
+ QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
+ launchUser.lambda().select(LaunchUserEntity::getId);
+ launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
+ launchUserMapper.deleteByIds(launchUserMapper.selectList(launchUser));
+ // 璇勮
+ QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
+ comment.lambda().select(CommentEntity::getId);
+ comment.lambda().in(CommentEntity::getTaskId, idAll);
+ commentMapper.deleteByIds(commentMapper.selectList(comment));
+ // 缁忓姙
+ QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
+ operator.lambda().select(OperatorEntity::getId);
+ operator.lambda().in(OperatorEntity::getTaskId, idAll);
+ operatorMapper.deleteByIds(operatorMapper.selectList(operator));
+ // 璁板綍
+ QueryWrapper<RecordEntity> recordEntityQueryWrapper = new QueryWrapper<>();
+ recordEntityQueryWrapper.lambda().select(RecordEntity::getId);
+ recordEntityQueryWrapper.lambda().in(RecordEntity::getTaskId, idAll);
+ recordMapper.deleteByIds(recordMapper.selectList(recordEntityQueryWrapper));
+ // 閫�鍥炰俊鎭�
+ List<TaskEntity> taskList = taskMapper.selectList(task);
+ List<String> rejectDataIds = taskList.stream().map(TaskEntity::getRejectDataId).collect(Collectors.toList());
+ if (CollUtil.isNotEmpty(rejectDataIds)) {
+ QueryWrapper<RejectDataEntity> rejectData = new QueryWrapper<>();
+ rejectData.lambda().select(RejectDataEntity::getId);
+ rejectData.lambda().in(RejectDataEntity::getId, rejectDataIds);
+ rejectDataMapper.deleteByIds(rejectDataMapper.selectList(rejectData));
+ }
+ // 鎶勯��
+ QueryWrapper<CirculateEntity> circulate = new QueryWrapper<>();
+ circulate.lambda().select(CirculateEntity::getId);
+ circulate.lambda().in(CirculateEntity::getTaskId, idAll);
+ circulateMapper.deleteByIds(circulateMapper.selectList(circulate));
+ // 浠诲姟鏉′欢
+ QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
+ taskLine.lambda().select(TaskLineEntity::getId);
+ taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
+ taskLineMapper.deleteByIds(taskLineMapper.selectList(taskLine));
+ // 鎾ら攢
+ QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
+ revoke.lambda().select(RevokeEntity::getId);
+ revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
+ revokeMapper.deleteByIds(revokeMapper.selectList(revoke));
+ //鑺傜偣娴佽浆
+ QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
+ nodeRecord.lambda().select(NodeRecordEntity::getId);
+ nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
+ nodeRecordMapper.deleteByIds(nodeRecordMapper.selectList(nodeRecord));
+ //澶栭儴浜嬩欢
+ QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
+ eventLog.lambda().select(EventLogEntity::getId);
+ eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
+ eventLogMapper.deleteByIds(eventLogMapper.selectList(eventLog));
+ // 浠诲姟娴佺▼
+ QueryWrapper<TriggerTaskEntity> triggerTask = new QueryWrapper<>();
+ triggerTask.lambda().select(TriggerTaskEntity::getId);
+ triggerTask.lambda().and(t -> t.in(TriggerTaskEntity::getTaskId, idAll).or().in(TriggerTaskEntity::getId, idAll));
+ List<TriggerTaskEntity> list = triggerTaskMapper.selectList(triggerTask);
+ List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
+ if (!ids.isEmpty()) {
+ triggerTaskMapper.deleteByIds(list);
+ QueryWrapper<TriggerRecordEntity> triggerRecord = new QueryWrapper<>();
+ triggerRecord.lambda().select(TriggerRecordEntity::getId);
+ triggerRecord.lambda().in(TriggerRecordEntity::getTriggerId, ids);
+ triggerRecordMapper.deleteByIds(triggerRecordMapper.selectList(triggerRecord));
+ QueryWrapper<TriggerLaunchflowEntity> triggerLaunch = new QueryWrapper<>();
+ triggerLaunch.lambda().select(TriggerLaunchflowEntity::getId);
+ triggerLaunch.lambda().in(TriggerLaunchflowEntity::getTriggerId, ids);
+ triggerLaunchflowMapper.deleteByIds(triggerLaunchflowMapper.selectList(triggerLaunch));
+ }
+ }
+ }
+
+
+ // 褰掓。 褰撳墠娴佺▼鎵�鏈変汉锛氬寘鍚祦绋嬬殑鍙戣捣浜恒�佹墍鏈夎妭鐐圭殑瀹℃壒浜哄強鎶勯�佷汉鍛橈紝涓嶅寘鍚姞绛惧拰杞浜哄憳锛涳紙瀹℃壒浜鸿鍙栧弬涓庡鎵圭殑浜猴級
+ public List<String> getListOfFile(String taskId) {
+ List<String> resList = new ArrayList<>();
+ List<OperatorEntity> operatorList = operatorMapper.getList(taskId);
+ if (CollUtil.isNotEmpty(operatorList)) {
+ List<Integer> status = ImmutableList.of(OperatorStateEnum.ADD_SIGN.getCode(), OperatorStateEnum.TRANSFER.getCode(),
+ OperatorStateEnum.ASSIST.getCode(), OperatorStateEnum.FUTILITY.getCode());
+ List<OperatorEntity> list = operatorList.stream()
+ .filter(e -> !status.contains(e.getStatus()) && e.getHandleStatus() != null)
+ .collect(Collectors.toList());
+
+ resList.addAll(list.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList()));
+ }
+ List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
+ if (CollUtil.isNotEmpty(circulateList)) {
+ resList.addAll(circulateList.stream().map(CirculateEntity::getUserId).collect(Collectors.toList()));
+ }
+ return resList.stream().distinct().collect(Collectors.toList());
+ }
+
+ // 褰掓。 鏈�鍚庤妭鐐瑰鎵逛汉锛氳〃绀烘渶鍚庤妭鐐圭殑瀹℃壒浜烘墠鏈夋潈闄愭煡鐪嬭鏂囨。锛堝彇鏈�鍚庤妭鐐瑰疄闄呭弬涓庡鎵圭殑浜猴紝涓嶅寘鍚姞绛惧拰杞浜哄憳锛夛紱
+ public List<String> getListOfLast(String taskId) {
+ List<String> resList = new ArrayList<>();
+
+ List<Integer> status = ImmutableList.of(OperatorStateEnum.ADD_SIGN.getCode(), OperatorStateEnum.TRANSFER.getCode(),
+ OperatorStateEnum.ASSIST.getCode(), OperatorStateEnum.FUTILITY.getCode());
+
+ QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
+ queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId)
+ .ne(OperatorEntity::getHandleId, FlowNature.SYSTEM_CODE)
+ .notIn(OperatorEntity::getStatus, status)
+ .isNotNull(OperatorEntity::getHandleStatus).orderByDesc(OperatorEntity::getHandleTime);
+
+ List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
+ if (CollUtil.isNotEmpty(list)) {
+ // 鑾峰彇绗﹀悎鏉′欢鐨勬渶鍚庝竴涓鎵逛汉锛岄�氳繃璇ュ鎵逛汉鑾峰彇鑺傜偣
+ OperatorEntity operator = list.get(0);
+ List<OperatorEntity> operatorList = list.stream()
+ .filter(e -> ObjectUtil.equals(operator.getNodeId(), e.getNodeId()))
+ .sorted(Comparator.comparing(OperatorEntity::getHandleTime).reversed()).collect(Collectors.toList());
+ if (CollUtil.isNotEmpty(operatorList)) {
+ List<String> handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList());
+ resList.addAll(handleIds);
+ }
+ List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
+ if (CollUtil.isNotEmpty(circulateList)) {
+ List<String> userIds = circulateList.stream().filter(e -> ObjectUtil.equals(operator.getNodeId(), e.getNodeId()))
+ .map(CirculateEntity::getUserId).collect(Collectors.toList());
+ resList.addAll(userIds);
+ }
+ }
+ return resList.stream().distinct().collect(Collectors.toList());
+ }
+
+}
--
Gitblit v1.8.0