package com.ruoyi.approve.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.approve.mapper.ApproveLogMapper;
|
import com.ruoyi.approve.mapper.ApproveNodeMapper;
|
import com.ruoyi.approve.mapper.ApproveProcessMapper;
|
import com.ruoyi.approve.pojo.ApproveLog;
|
import com.ruoyi.approve.pojo.ApproveNode;
|
import com.ruoyi.approve.pojo.ApproveProcess;
|
import com.ruoyi.approve.service.IApproveNodeService;
|
import com.ruoyi.approve.vo.ApproveNodeVO;
|
import com.ruoyi.common.enums.FileNameType;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.other.service.impl.TempFileServiceImpl;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.sales.mapper.CommonFileMapper;
|
import com.ruoyi.sales.pojo.CommonFile;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.List;
|
|
@Service
|
@RequiredArgsConstructor
|
public class ApproveNodeServiceImpl extends ServiceImpl<ApproveNodeMapper, ApproveNode> implements IApproveNodeService {
|
private final ApproveNodeMapper approveNodeMapper;
|
private final ApproveProcessMapper approveProcessMapper;
|
private final ApproveLogMapper approveLogMapper;
|
private final SysUserMapper sysUserMapper;
|
private final TempFileServiceImpl tempFileService;
|
private final CommonFileMapper fileMapper;
|
|
private ApproveProcess getApproveById(String code) {
|
ApproveProcess process = approveProcessMapper.selectOne(new LambdaQueryWrapper<ApproveProcess>()
|
.eq(ApproveProcess::getApproveId, code)
|
.eq(ApproveProcess::getApproveDelete, 0)
|
.eq(ApproveProcess::getTenantId, tenantId())
|
.last("limit 1"));
|
if (process == null) throw new RuntimeException("审批不存在");
|
return process;
|
}
|
|
@Override
|
public void initApproveNodes(String approveUserIds, String approveID, Long tenantId) {
|
if (!StringUtils.hasText(approveUserIds)) throw new RuntimeException("请选择审批人");
|
List<ApproveNodeVO> nodes = new ArrayList<>();
|
for (String id : approveUserIds.split(",")) {
|
ApproveNodeVO node = new ApproveNodeVO();
|
node.setUserId(Long.parseLong(id.trim()));
|
node.setConditionOperator("ALWAYS");
|
nodes.add(node);
|
}
|
initApproveNodes(nodes, approveID, tenantId);
|
}
|
|
@Override
|
public void initApproveNodes(List<ApproveNodeVO> nodes, String approveID, Long ignoredTenantId) {
|
if (CollectionUtils.isEmpty(nodes)) throw new RuntimeException("审批流程至少包含一个节点");
|
Long tenantId = tenantId();
|
Long currentUserId = SecurityUtils.getUserId();
|
ApproveProcess process = getApproveById(approveID);
|
int order = 1;
|
ApproveNode first = null;
|
Long previousUserId = null;
|
for (ApproveNodeVO request : nodes) {
|
if (request.getUserId() == null) throw new RuntimeException("审批人不能为空");
|
if (request.getUserId().equals(previousUserId)) throw new RuntimeException("相邻审批节点不能选择同一审批人");
|
previousUserId = request.getUserId();
|
if (!matchesCondition(process.getAmount(), request)) continue;
|
SysUser user = sysUserMapper.selectUserById(request.getUserId());
|
if (user == null || !tenantId.equals(user.getTenantId())) throw new RuntimeException("审批人不存在或不属于当前租户");
|
ApproveNode node = new ApproveNode();
|
node.setApproveProcessId(process.getApproveId());
|
node.setApproveNodeOrder(order++);
|
node.setApproveNodeName(StringUtils.hasText(request.getNodeName()) ? request.getNodeName() : "审批");
|
node.setApproveNodeUser(user.getNickName());
|
node.setApproveNodeUserId(user.getUserId());
|
node.setApproveNodeStatus(0);
|
node.setConditionField(request.getConditionField());
|
node.setConditionOperator(StringUtils.hasText(request.getConditionOperator()) ? request.getConditionOperator() : "ALWAYS");
|
node.setConditionValue(request.getConditionValue());
|
node.setIsCurrent(first == null ? 1 : 0);
|
node.setTenantId(tenantId);
|
node.setDeleteFlag(0);
|
node.setCreateUser(currentUserId);
|
node.setUpdateUser(currentUserId);
|
node.setCreateTime(LocalDateTime.now());
|
node.setUpdateTime(LocalDateTime.now());
|
approveNodeMapper.insert(node);
|
if (first == null) first = node;
|
}
|
if (first == null) throw new RuntimeException("没有满足条件的审批节点");
|
process.setApproveUserCurrentId(first.getApproveNodeUserId());
|
process.setApproveUserCurrentName(first.getApproveNodeUser());
|
process.setUpdateTime(LocalDateTime.now());
|
approveProcessMapper.updateById(process);
|
}
|
|
private boolean matchesCondition(BigDecimal amount, ApproveNodeVO node) {
|
String operator = node.getConditionOperator();
|
if (!StringUtils.hasText(operator) || "ALWAYS".equalsIgnoreCase(operator)) return true;
|
if (!"amount".equals(node.getConditionField())) throw new RuntimeException("审批条件仅支持金额字段");
|
if (amount == null || !StringUtils.hasText(node.getConditionValue())) return false;
|
try {
|
if ("BETWEEN".equalsIgnoreCase(operator)) {
|
String[] values = node.getConditionValue().replace("[", "").replace("]", "").split(",");
|
if (values.length != 2) throw new RuntimeException("金额区间格式不正确");
|
return amount.compareTo(new BigDecimal(values[0].trim())) >= 0
|
&& amount.compareTo(new BigDecimal(values[1].trim())) <= 0;
|
}
|
int compared = amount.compareTo(new BigDecimal(node.getConditionValue()));
|
if ("GT".equalsIgnoreCase(operator)) return compared > 0;
|
if ("GTE".equalsIgnoreCase(operator)) return compared >= 0;
|
if ("LT".equalsIgnoreCase(operator)) return compared < 0;
|
if ("LTE".equalsIgnoreCase(operator)) return compared <= 0;
|
if ("EQ".equalsIgnoreCase(operator)) return compared == 0;
|
} catch (NumberFormatException ex) {
|
throw new RuntimeException("审批条件金额格式不正确");
|
}
|
throw new RuntimeException("不支持的审批条件操作符");
|
}
|
|
@Override
|
public List<ApproveNode> details(String id) {
|
getApproveById(id);
|
List<ApproveNode> nodes = approveNodeMapper.selectList(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getApproveProcessId, id)
|
.eq(ApproveNode::getDeleteFlag, 0)
|
.eq(ApproveNode::getTenantId, tenantId())
|
.orderByAsc(ApproveNode::getApproveNodeOrder));
|
for (ApproveNode node : nodes) {
|
List<CommonFile> files = fileMapper.selectList(new LambdaQueryWrapper<CommonFile>()
|
.eq(CommonFile::getCommonId, node.getId())
|
.eq(CommonFile::getType, FileNameType.ApproveNode.getValue()));
|
if (!CollectionUtils.isEmpty(files)) node.setUrl(files.get(0).getUrl());
|
node.setIsShen(Integer.valueOf(1).equals(node.getIsCurrent())
|
&& node.getApproveNodeUserId().equals(SecurityUtils.getUserId()));
|
}
|
nodes.sort(Comparator.comparingInt(ApproveNode::getApproveNodeOrder));
|
return nodes;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateApproveNode(ApproveNode request) throws IOException {
|
if (request == null || request.getId() == null) throw new RuntimeException("审批节点不能为空");
|
if (request.getApproveNodeStatus() == null || (request.getApproveNodeStatus() != 1 && request.getApproveNodeStatus() != 2)) {
|
throw new RuntimeException("审批结果不正确");
|
}
|
if (!StringUtils.hasText(request.getApproveNodeReason())) throw new RuntimeException("审批意见不能为空");
|
Long tenantId = tenantId();
|
ApproveNode node = approveNodeMapper.selectOne(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getId, request.getId())
|
.eq(ApproveNode::getTenantId, tenantId)
|
.eq(ApproveNode::getDeleteFlag, 0));
|
if (node == null) throw new RuntimeException("审批节点不存在");
|
if (!Integer.valueOf(0).equals(node.getApproveNodeStatus()) || !Integer.valueOf(1).equals(node.getIsCurrent())) {
|
throw new RuntimeException("该节点已经处理或不是当前审批节点");
|
}
|
if (!SecurityUtils.getUserId().equals(node.getApproveNodeUserId())) throw new RuntimeException("当前用户无权审批此节点");
|
|
ApproveProcess process = getApproveById(node.getApproveProcessId());
|
if (Integer.valueOf(2).equals(process.getApproveStatus()) || Integer.valueOf(3).equals(process.getApproveStatus())) {
|
throw new RuntimeException("审批流程已经结束");
|
}
|
node.setApproveNodeStatus(request.getApproveNodeStatus());
|
node.setApproveNodeReason(request.getApproveNodeReason().trim());
|
node.setApproveNodeRemark(request.getApproveNodeRemark());
|
node.setApproveNodeTime(new Date());
|
node.setIsCurrent(0);
|
node.setUpdateUser(SecurityUtils.getUserId());
|
node.setUpdateTime(LocalDateTime.now());
|
approveNodeMapper.updateById(node);
|
|
if (node.getApproveNodeStatus() == 2) {
|
process.setApproveStatus(3);
|
process.setApproveUserCurrentId(null);
|
process.setApproveUserCurrentName(null);
|
process.setApproveOverTime(new Date());
|
} else {
|
ApproveNode next = approveNodeMapper.selectOne(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getApproveProcessId, node.getApproveProcessId())
|
.eq(ApproveNode::getTenantId, tenantId)
|
.eq(ApproveNode::getDeleteFlag, 0)
|
.eq(ApproveNode::getApproveNodeStatus, 0)
|
.gt(ApproveNode::getApproveNodeOrder, node.getApproveNodeOrder())
|
.orderByAsc(ApproveNode::getApproveNodeOrder)
|
.last("limit 1"));
|
if (next == null) {
|
process.setApproveStatus(2);
|
process.setApproveOverTime(new Date());
|
process.setApproveUserCurrentId(null);
|
process.setApproveUserCurrentName(null);
|
} else {
|
next.setIsCurrent(1);
|
next.setUpdateTime(LocalDateTime.now());
|
approveNodeMapper.updateById(next);
|
process.setApproveStatus(1);
|
process.setApproveUserCurrentId(next.getApproveNodeUserId());
|
process.setApproveUserCurrentName(next.getApproveNodeUser());
|
}
|
}
|
process.setUpdateTime(LocalDateTime.now());
|
approveProcessMapper.updateById(process);
|
|
ApproveLog log = new ApproveLog();
|
log.setApproveId(process.getId());
|
log.setApproveProcessId(process.getId());
|
log.setApproveNodeId(node.getId());
|
log.setApproveNodeOrder(node.getApproveNodeOrder());
|
log.setApproveUser(SecurityUtils.getUserId());
|
log.setApproveUserName(node.getApproveNodeUser());
|
log.setApproveTime(new Date());
|
log.setApproveStatus(node.getApproveNodeStatus());
|
log.setApproveRemark(node.getApproveNodeReason());
|
log.setTenantId(tenantId);
|
approveLogMapper.insert(log);
|
|
if (!CollectionUtils.isEmpty(request.getTempFileIds()) && node.getApproveNodeStatus() == 1) {
|
tempFileService.migrateTempFilesToFormal(node.getId(), request.getTempFileIds(), FileNameType.ApproveNode.getValue());
|
}
|
}
|
|
@Override
|
public void delApproveNodeByApproveId(String id) {
|
UpdateWrapper<ApproveNode> wrapper = new UpdateWrapper<>();
|
wrapper.lambda().set(ApproveNode::getDeleteFlag, 1)
|
.set(ApproveNode::getIsCurrent, 0)
|
.eq(ApproveNode::getApproveProcessId, id)
|
.eq(ApproveNode::getTenantId, tenantId());
|
update(wrapper);
|
}
|
|
private Long tenantId() {
|
return SecurityUtils.getLoginUser().getTenantId();
|
}
|
}
|
