package jnpf.flowable.mapper;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import cn.hutool.core.util.ObjectUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.github.yulichang.toolkit.JoinWrappers;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import com.google.common.collect.ImmutableList;
|
import com.google.common.collect.ImmutableMap;
|
import com.google.common.collect.Lists;
|
import jnpf.base.mapper.SuperMapper;
|
import jnpf.constant.MsgCode;
|
import jnpf.exception.WorkFlowException;
|
import jnpf.flowable.entity.OperatorEntity;
|
import jnpf.flowable.entity.RecordEntity;
|
import jnpf.flowable.entity.TaskEntity;
|
import jnpf.flowable.entity.TemplateEntity;
|
import jnpf.flowable.enums.RecordEnum;
|
import jnpf.flowable.enums.TaskStatusEnum;
|
import jnpf.flowable.model.monitor.MonitorVo;
|
import jnpf.flowable.model.operator.OperatorVo;
|
import jnpf.flowable.model.task.FlowModel;
|
import jnpf.flowable.model.task.TaskPagination;
|
import jnpf.flowable.model.util.FlowNature;
|
import jnpf.util.StringUtil;
|
import jnpf.util.UserProvider;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 类的描述
|
*
|
* @author JNPF@YinMai Info. Co., Ltd
|
* @version 5.0.x
|
* @since 2024/4/17 15:07
|
*/
|
public interface TaskMapper extends SuperMapper<TaskEntity> {
|
|
|
default boolean checkAsync(String id) {
|
List<TaskEntity> childList = this.getChildList(id, TaskEntity::getId, TaskEntity::getIsAsync);
|
return childList.stream().anyMatch(e -> FlowNature.ChildAsync.equals(e.getIsAsync()));
|
}
|
|
default List<OperatorVo> getList(TaskPagination pagination,List<RecordEntity> recordList){
|
if (recordList.isEmpty()) {
|
return new ArrayList<>();
|
}
|
List<String> taskId = recordList.stream().map(RecordEntity::getTaskId).collect(Collectors.toList());
|
List<String> nodeCode = recordList.stream().map(RecordEntity::getNodeCode).collect(Collectors.toList());
|
List<Date> handleTime = recordList.stream().map(RecordEntity::getHandleTime).collect(Collectors.toList());
|
MPJLambdaWrapper<TaskEntity> wrapper = JoinWrappers.lambda(TaskEntity.class)
|
.leftJoin(RecordEntity.class, RecordEntity::getTaskId, TaskEntity::getId)
|
.leftJoin(OperatorEntity.class, OperatorEntity::getId, RecordEntity::getOperatorId)
|
.leftJoin(TemplateEntity.class, TemplateEntity::getId, TaskEntity::getTemplateId)
|
.selectAll(TaskEntity.class)
|
.selectAs(TaskEntity::getUrgent, OperatorVo::getFlowUrgent)
|
.selectAs(RecordEntity::getId, OperatorVo::getId)
|
.selectAs(RecordEntity::getNodeName, OperatorVo::getCurrentNodeName)
|
.selectAs(RecordEntity::getNodeCode, OperatorVo::getNodeCode)
|
.selectAs(RecordEntity::getHandleType, OperatorVo::getStatus)
|
.selectAs(RecordEntity::getHandleId, OperatorVo::getHandleId)
|
.selectAs(RecordEntity::getHandleTime, OperatorVo::getCreatorTime)
|
.selectAs(OperatorEntity::getHandleId, OperatorVo::getOperatorHandleId)
|
.selectAs(RecordEntity::getTaskId, OperatorVo::getTaskId)
|
.selectAs(TemplateEntity::getSystemId, OperatorVo::getSystemName)
|
.selectAs(RecordEntity::getCreatorUserId, OperatorVo::getRecordCreatorUserId)
|
.selectAs(TaskEntity::getCreatorUserId, OperatorVo::getCreatorUserId)
|
.in(RecordEntity::getTaskId, taskId)
|
.in(RecordEntity::getNodeCode, nodeCode)
|
.ne(TaskEntity::getStatus, TaskStatusEnum.CANCEL.getCode());
|
|
if (CollectionUtil.isNotEmpty(handleTime)) {
|
List<List<Date>> dateList = Lists.partition(handleTime, 1000);
|
wrapper.and(e -> {
|
for (List<Date> list : dateList) {
|
e.or().in(RecordEntity::getHandleTime, list);
|
}
|
});
|
// wrapper.and(e -> {
|
// for (Date date : handleTime) {
|
// Calendar start = Calendar.getInstance();
|
// start.setTime(date);
|
// start.set(Calendar.MILLISECOND, 0);
|
// Calendar end = Calendar.getInstance();
|
// end.setTime(date);
|
// end.set(Calendar.MILLISECOND, 999);
|
// e.or(t -> t.between(RecordEntity::getHandleTime, start.getTime(), end.getTime()));
|
// }
|
// });
|
}
|
|
Map<Integer, List<Integer>> statusMap = ImmutableMap.of(
|
1, ImmutableList.of(RecordEnum.audit.getCode()),// 同意
|
2, ImmutableList.of(RecordEnum.reject.getCode()),// 拒绝
|
3, ImmutableList.of(RecordEnum.transfer.getCode(), RecordEnum.transferProcessing.getCode()),// 转审
|
4, ImmutableList.of(RecordEnum.addSign.getCode()),// 加签
|
5, ImmutableList.of(RecordEnum.back.getCode())// 退回
|
);
|
|
Integer status = pagination.getStatus();
|
List<Integer> handleType = statusMap.get(status);
|
if (ObjectUtil.isNotEmpty(handleType)) {
|
wrapper.in(RecordEntity::getHandleType, handleType);
|
}
|
String keyWord = pagination.getKeyword();
|
if (ObjectUtil.isNotEmpty(keyWord)) {
|
wrapper.and(t -> t.like(TaskEntity::getEnCode, keyWord).or().like(TaskEntity::getFullName, keyWord));
|
}
|
//所属分类
|
String category = pagination.getFlowCategory();
|
if (ObjectUtil.isNotEmpty(category)) {
|
List<String> categoryList = Arrays.stream(category.split(",")).collect(Collectors.toList());
|
wrapper.in(TaskEntity::getFlowCategory, categoryList);
|
}
|
// 所属流程
|
String templateId = pagination.getTemplateId();
|
if (ObjectUtil.isNotEmpty(templateId)) {
|
wrapper.eq(TaskEntity::getTemplateId, templateId);
|
}
|
// 紧急程度
|
Integer flowUrgent = pagination.getFlowUrgent();
|
if (ObjectUtil.isNotEmpty(flowUrgent)) {
|
wrapper.eq(TaskEntity::getUrgent, flowUrgent);
|
}
|
// 发起人员
|
String creatorUserId = pagination.getCreatorUserId();
|
if (ObjectUtil.isNotEmpty(creatorUserId)) {
|
wrapper.eq(TaskEntity::getCreatorUserId, creatorUserId);
|
}
|
// 日期范围（近7天、近1月、近3月、自定义）
|
if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
|
wrapper.between(TaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
|
}
|
//应用主建
|
String systemId = pagination.getSystemId();
|
if (ObjectUtil.isNotEmpty(systemId)) {
|
wrapper.eq(TemplateEntity::getSystemId, systemId);
|
}
|
wrapper.orderByDesc(RecordEntity::getHandleTime);
|
|
Page<OperatorVo> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
|
Page<OperatorVo> data = this.selectJoinPage(page, OperatorVo.class, wrapper);
|
for (OperatorVo record : data.getRecords()) {
|
if (StringUtil.isEmpty(record.getOperatorHandleId())){
|
continue;
|
}
|
if (ObjectUtil.equals(record.getStatus(), RecordEnum.transfer.getCode())){
|
continue;
|
}
|
boolean isUser = ObjectUtil.equals(record.getHandleId(), record.getRecordCreatorUserId());
|
record.setDelegateUser(!isUser ? record.getRecordCreatorUserId() : null);
|
}
|
return pagination.setData(data.getRecords(), page.getTotal());
|
|
}
|
|
default List<TaskEntity> subFlowInfo(FlowModel flowModel) throws WorkFlowException {
|
String taskId = flowModel.getTaskId();
|
String nodeCode = flowModel.getNodeCode();
|
QueryWrapper<TaskEntity> wrapper = new QueryWrapper<>();
|
wrapper.lambda().eq(TaskEntity::getParentId, taskId).eq(TaskEntity::getSubCode, nodeCode);
|
List<TaskEntity> entityList = this.selectList(wrapper);
|
return entityList;
|
}
|
|
default List<TaskEntity> getChildList(String id, SFunction<TaskEntity, ?>... columns) {
|
return getChildList(ImmutableList.of(id), columns);
|
}
|
|
default List<TaskEntity> getChildList(List<String> id, SFunction<TaskEntity, ?>... columns) {
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().select(columns).in(TaskEntity::getParentId, id);
|
return this.selectList(queryWrapper);
|
}
|
|
default List<String> getChildAllList(String id) {
|
List<String> idAll = new ArrayList<>();
|
List<String> idList = ImmutableList.of(id);
|
this.deleTaskAll(idList, idAll);
|
return idAll;
|
}
|
|
default void getChildList(String id, boolean suspend, List<String> list) {
|
List<TaskEntity> taskAll = this.getChildList(id, TaskEntity::getId, TaskEntity::getIsAsync);
|
if (suspend) {
|
taskAll = taskAll.stream().filter(t -> FlowNature.ChildSync.equals(t.getIsAsync())).collect(Collectors.toList());
|
}
|
for (TaskEntity entity : taskAll) {
|
list.add(entity.getId());
|
this.getChildList(entity.getId(), suspend, list);
|
}
|
}
|
|
default void deleTaskAll(List<String> idList, List<String> idAll) {
|
idAll.addAll(idList);
|
for (String id : idList) {
|
List<TaskEntity> taskAll = this.getChildList(id, TaskEntity::getId);
|
List<String> list = taskAll.stream().map(TaskEntity::getId).collect(Collectors.toList());
|
this.deleTaskAll(list, idAll);
|
}
|
}
|
|
default List<TaskEntity> getOrderStaList(List<String> ids) {
|
List<TaskEntity> list = new ArrayList<>();
|
if (CollectionUtil.isNotEmpty(ids)) {
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().in(TaskEntity::getId, ids);
|
list = this.selectList(queryWrapper);
|
}
|
return list;
|
}
|
|
default List<TaskEntity> getTaskByTemplate(String templateId) {
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(TaskEntity::getTemplateId, templateId);
|
return this.selectList(queryWrapper);
|
}
|
|
default TaskEntity getInfoSubmit(String id, SFunction<TaskEntity, ?>... columns) {
|
List<TaskEntity> list = getInfosSubmit(new String[]{id}, columns);
|
if (list.isEmpty()) {
|
return null;
|
}
|
return list.get(0);
|
}
|
|
default List<TaskEntity> getInfosSubmit(String[] ids, SFunction<TaskEntity, ?>... columns) {
|
List<TaskEntity> resultList = Collections.emptyList();
|
if (ids == null || ids.length == 0) {
|
return resultList;
|
}
|
LambdaQueryWrapper<TaskEntity> queryWrapper = new LambdaQueryWrapper<>();
|
if (ids.length == 1) {
|
queryWrapper.select(columns).and(
|
t -> t.eq(TaskEntity::getId, ids[0])
|
);
|
resultList = this.selectList(queryWrapper);
|
if (resultList.isEmpty()) {
|
queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.select(columns).and(
|
t -> t.eq(TaskEntity::getFlowId, ids[0])
|
);
|
resultList = this.selectList(queryWrapper);
|
}
|
} else {
|
queryWrapper.select(TaskEntity::getId).and(t -> {
|
t.in(TaskEntity::getId, ids).or().in(TaskEntity::getId, ids);
|
});
|
List<String> resultIds = this.selectList(queryWrapper).stream().map(TaskEntity::getId).collect(Collectors.toList());
|
if (!resultIds.isEmpty()) {
|
queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.select(columns).in(TaskEntity::getId, resultIds);
|
resultList = this.selectList(queryWrapper);
|
}
|
}
|
return resultList;
|
}
|
|
|
default List<MonitorVo> getMonitorList(TaskPagination pagination) {
|
// 定义变量判断是否需要使用修改时间倒序
|
boolean flag = false;
|
|
MPJLambdaWrapper<TaskEntity> wrapper = JoinWrappers.lambda(TaskEntity.class)
|
.selectAll(TaskEntity.class)
|
.selectAs(TaskEntity::getCreatorUserId, MonitorVo::getCreatorUser)
|
.selectAs(TaskEntity::getUrgent, MonitorVo::getFlowUrgent)
|
.selectAs(TaskEntity::getFlowName, MonitorVo::getFlowName)
|
.selectAs(TemplateEntity::getSystemId, MonitorVo::getSystemName)
|
.leftJoin(TemplateEntity.class, TemplateEntity::getId, TaskEntity::getTemplateId)
|
.isNotNull(TaskEntity::getStartTime)
|
.gt(TaskEntity::getStatus, TaskStatusEnum.TO_BE_SUBMIT.getCode());
|
|
//关键字（流程名称、流程编码）
|
String keyWord = pagination.getKeyword();
|
if (ObjectUtil.isNotEmpty(keyWord)) {
|
flag = true;
|
wrapper.and(t -> t.like(TaskEntity::getEnCode, keyWord).or().like(TaskEntity::getFullName, keyWord));
|
}
|
//日期范围（近7天、近1月、近3月、自定义）
|
if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
|
wrapper.between(TaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
|
}
|
//所属流程
|
String templateId = pagination.getTemplateId();
|
if (ObjectUtil.isNotEmpty(templateId)) {
|
flag = true;
|
wrapper.eq(TaskEntity::getTemplateId, templateId);
|
}
|
//流程状态
|
Integer status = pagination.getStatus();
|
if (ObjectUtil.isNotEmpty(status)) {
|
flag = true;
|
wrapper.eq(TaskEntity::getStatus, status);
|
}
|
//紧急程度
|
Integer flowUrgent = pagination.getFlowUrgent();
|
if (ObjectUtil.isNotEmpty(flowUrgent)) {
|
flag = true;
|
wrapper.eq(TaskEntity::getUrgent, flowUrgent);
|
}
|
//所属分类
|
String flowCategory = pagination.getFlowCategory();
|
if (ObjectUtil.isNotEmpty(flowCategory)) {
|
flag = true;
|
wrapper.eq(TaskEntity::getFlowCategory, flowCategory);
|
}
|
// 发起人员
|
String creatorUserId = pagination.getCreatorUserId();
|
if (StringUtil.isNotBlank(creatorUserId)) {
|
flag = true;
|
wrapper.eq(TaskEntity::getCreatorUserId, creatorUserId);
|
}
|
//应用主建
|
String systemId = pagination.getSystemId();
|
if (ObjectUtil.isNotEmpty(systemId)) {
|
wrapper.eq(TemplateEntity::getSystemId, systemId);
|
}
|
wrapper.orderByDesc(TaskEntity::getStartTime);
|
if (flag) {
|
wrapper.orderByDesc(TaskEntity::getLastModifyTime);
|
}
|
|
Page<MonitorVo> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
|
Page<MonitorVo> iPage = this.selectJoinPage(page, MonitorVo.class, wrapper);
|
return pagination.setData(iPage.getRecords(), page.getTotal());
|
}
|
|
default TaskEntity getInfo(String id) throws WorkFlowException {
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(TaskEntity::getId, id == null ? "" : id);
|
TaskEntity entity = this.selectOne(queryWrapper);
|
if (null == entity) {
|
throw new WorkFlowException(MsgCode.FA001.get());
|
}
|
return entity;
|
}
|
|
default List<TaskEntity> getSubTask(String taskId, List<String> nodeCodes) {
|
if (StringUtil.isEmpty(taskId)) {
|
return new ArrayList<>();
|
}
|
QueryWrapper<TaskEntity> queryWrapper = new QueryWrapper<>();
|
queryWrapper.lambda().eq(TaskEntity::getParentId, taskId);
|
if (CollectionUtil.isNotEmpty(nodeCodes)) {
|
queryWrapper.lambda().in(TaskEntity::getSubCode, nodeCodes);
|
}
|
return this.selectList(queryWrapper);
|
}
|
}
|
