package jnpf.flowable.util;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
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.NodeEnum;
|
import jnpf.flowable.enums.OperatorStateEnum;
|
import jnpf.flowable.enums.TaskStatusEnum;
|
import jnpf.flowable.mapper.*;
|
import jnpf.flowable.model.util.FlowNature;
|
import jnpf.flowable.service.RejectDataService;
|
import jnpf.util.StringUtil;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
@Component
|
public class VisuladeUtil {
|
|
@Autowired
|
private TaskMapper taskMapper;
|
@Autowired
|
private TemplateJsonMapper templateJsonMapper;
|
@Autowired
|
private TemplateNodeMapper templateNodeMapper;
|
@Autowired
|
private LaunchUserMapper launchUserMapper;
|
@Autowired
|
private CandidatesMapper candidatesMapper;
|
@Autowired
|
private OperatorMapper operatorMapper;
|
@Autowired
|
private RecordMapper recordMapper;
|
@Autowired
|
private CirculateMapper circulateMapper;
|
@Autowired
|
private CommentMapper commentMapper;
|
@Autowired
|
private RejectDataService rejectDataService;
|
@Autowired
|
private NodeRecordMapper nodeRecordMapper;
|
@Autowired
|
private TaskLineMapper taskLineMapper;
|
@Autowired
|
private RevokeMapper revokeMapper;
|
@Autowired
|
private TriggerTaskMapper triggerTaskMapper;
|
@Autowired
|
private TriggerRecordMapper triggerRecordMapper;
|
@Autowired
|
private EventLogMapper eventLogMapper;
|
@Autowired
|
private TemplateUseNumMapper templateUseNumMapper;
|
|
|
public List<TaskEntity> delete(String id) throws Exception {
|
TaskEntity entity = taskMapper.selectById(id);
|
if (null == entity) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
if (TaskStatusEnum.PAUSED.getCode().equals(entity.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF114.get());
|
}
|
List<Integer> status = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.RECALL.getCode());
|
if (!status.contains(entity.getStatus())) {
|
throw new WorkFlowException(MsgCode.WF063.get());
|
}
|
if (StringUtil.isNotEmpty(entity.getParentId()) && !FlowNature.ParentId.equals(entity.getParentId())) {
|
throw new WorkFlowException(entity.getFullName() + MsgCode.WF021.get());
|
}
|
|
List<String> idList = ImmutableList.of(entity.getId());
|
this.delete(idList);
|
List<TaskEntity> list = ImmutableList.of(entity);
|
return list;
|
}
|
|
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.setIgnoreLogicDelete().deleteByIds(taskMapper.selectList(task));
|
taskMapper.clearIgnoreLogicDelete();
|
// 候选人
|
QueryWrapper<CandidatesEntity> candidates = new QueryWrapper<>();
|
candidates.lambda().select(CandidatesEntity::getId);
|
candidates.lambda().in(CandidatesEntity::getTaskId, idAll);
|
candidatesMapper.setIgnoreLogicDelete().deleteByIds(candidatesMapper.selectList(candidates));
|
candidatesMapper.clearIgnoreLogicDelete();
|
// 发起人
|
QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
|
launchUser.lambda().select(LaunchUserEntity::getId);
|
launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
|
launchUserMapper.setIgnoreLogicDelete().deleteByIds(launchUserMapper.selectList(launchUser));
|
launchUserMapper.clearIgnoreLogicDelete();
|
// 评论
|
QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
|
comment.lambda().select(CommentEntity::getId);
|
comment.lambda().in(CommentEntity::getTaskId, idAll);
|
commentMapper.setIgnoreLogicDelete().deleteByIds(commentMapper.selectList(comment));
|
commentMapper.clearIgnoreLogicDelete();
|
// 经办
|
QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
|
operator.lambda().select(OperatorEntity::getId);
|
operator.lambda().in(OperatorEntity::getTaskId, idAll);
|
operatorMapper.setIgnoreLogicDelete().deleteByIds(operatorMapper.selectList(operator));
|
operatorMapper.clearIgnoreLogicDelete();
|
// 记录
|
QueryWrapper<RecordEntity> record = new QueryWrapper<>();
|
record.lambda().select(RecordEntity::getId);
|
record.lambda().in(RecordEntity::getTaskId, idAll);
|
recordMapper.setIgnoreLogicDelete().deleteByIds(recordMapper.selectList(record));
|
recordMapper.clearIgnoreLogicDelete();
|
// 退回信息
|
List<TaskEntity> taskList = taskMapper.selectList(task);
|
List<String> rejectDataIds = taskList.stream().map(TaskEntity::getRejectDataId).collect(Collectors.toList());
|
if (CollectionUtil.isNotEmpty(rejectDataIds)) {
|
QueryWrapper<RejectDataEntity> rejectData = new QueryWrapper<>();
|
rejectData.lambda().select(RejectDataEntity::getId);
|
rejectData.lambda().in(RejectDataEntity::getId, rejectDataIds);
|
rejectDataService.setIgnoreLogicDelete().removeByIds(rejectDataService.list(rejectData));
|
rejectDataService.clearIgnoreLogicDelete();
|
}
|
// 抄送
|
QueryWrapper<CirculateEntity> circulate = new QueryWrapper<>();
|
circulate.lambda().select(CirculateEntity::getId);
|
circulate.lambda().in(CirculateEntity::getTaskId, idAll);
|
circulateMapper.setIgnoreLogicDelete().deleteByIds(circulateMapper.selectList(circulate));
|
circulateMapper.clearIgnoreLogicDelete();
|
// 任务条件
|
QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
|
taskLine.lambda().select(TaskLineEntity::getId);
|
taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
|
taskLineMapper.setIgnoreLogicDelete().deleteByIds(taskLineMapper.selectList(taskLine));
|
taskLineMapper.clearIgnoreLogicDelete();
|
// 撤销
|
QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
|
revoke.lambda().select(RevokeEntity::getId);
|
revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
|
revokeMapper.setIgnoreLogicDelete().deleteByIds(revokeMapper.selectList(revoke));
|
revokeMapper.clearIgnoreLogicDelete();
|
//节点流转
|
QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
|
nodeRecord.lambda().select(NodeRecordEntity::getId);
|
nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
|
nodeRecordMapper.setIgnoreLogicDelete().deleteByIds(nodeRecordMapper.selectList(nodeRecord));
|
nodeRecordMapper.clearIgnoreLogicDelete();
|
//外部事件
|
QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
|
eventLog.lambda().select(EventLogEntity::getId);
|
eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
|
eventLogMapper.setIgnoreLogicDelete().deleteByIds(eventLogMapper.selectList(eventLog));
|
eventLogMapper.clearIgnoreLogicDelete();
|
// 任务流程
|
QueryWrapper<TriggerTaskEntity> triggerTask = new QueryWrapper<>();
|
triggerTask.lambda().select(TriggerTaskEntity::getId);
|
triggerTask.lambda().in(TriggerTaskEntity::getTaskId, idAll);
|
List<TriggerTaskEntity> list = triggerTaskMapper.selectList(triggerTask);
|
if (!list.isEmpty()) {
|
List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
|
triggerTaskMapper.setIgnoreLogicDelete().deleteByIds(list);
|
triggerTaskMapper.clearIgnoreLogicDelete();
|
QueryWrapper<TriggerRecordEntity> triggerRecord = new QueryWrapper<>();
|
triggerRecord.lambda().select(TriggerRecordEntity::getId);
|
triggerRecord.lambda().in(TriggerRecordEntity::getTriggerId, ids);
|
triggerRecordMapper.setIgnoreLogicDelete().deleteByIds(triggerRecordMapper.selectList(triggerRecord));
|
triggerRecordMapper.clearIgnoreLogicDelete();
|
}
|
}
|
}
|
|
|
// 归档 当前流程所有人：包含流程的发起人、所有节点的审批人及抄送人员，不包含加签和转审人员；（审批人读取参与审批的人）
|
public List<String> getListOfFile(String taskId) {
|
List<String> resList = new ArrayList<>();
|
List<OperatorEntity> operatorList = operatorMapper.getList(taskId);
|
if (CollectionUtil.isNotEmpty(operatorList)) {
|
List<Integer> status = ImmutableList.of(OperatorStateEnum.AddSign.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 (CollectionUtil.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.AddSign.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 (CollectionUtil.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 (CollectionUtil.isNotEmpty(operatorList)) {
|
List<String> handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList());
|
resList.addAll(handleIds);
|
}
|
List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
|
if (CollectionUtil.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());
|
}
|
|
public List<String> getFormList() {
|
List<String> resList = new ArrayList<>();
|
List<TemplateJsonEntity> list = templateJsonMapper.getListOfEnable();
|
if (CollectionUtil.isNotEmpty(list)) {
|
List<String> flowIds = list.stream().map(TemplateJsonEntity::getId).distinct().collect(Collectors.toList());
|
List<TemplateNodeEntity> startNodeList = templateNodeMapper.getList(flowIds, NodeEnum.start.getType());
|
resList = startNodeList.stream().map(TemplateNodeEntity::getFormId).distinct().collect(Collectors.toList());
|
}
|
return resList;
|
}
|
|
|
}
|
