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.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.approve.mapper.ApproveNodeMapper;
|
import com.ruoyi.approve.mapper.ApproveProcessMapper;
|
import com.ruoyi.approve.pojo.ApproveNode;
|
import com.ruoyi.approve.pojo.ApproveProcess;
|
import com.ruoyi.approve.service.IApproveNodeService;
|
import com.ruoyi.approve.service.IApproveProcessService;
|
import com.ruoyi.approve.utils.DailyRedisCounter;
|
import com.ruoyi.approve.vo.ApproveGetAndUpdateVo;
|
import com.ruoyi.approve.vo.ApproveProcessVO;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.project.system.domain.SysDept;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysDeptMapper;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import lombok.AllArgsConstructor;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
import org.springframework.util.StringUtils;
|
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Date;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class ApproveProcessServiceImpl extends ServiceImpl<ApproveProcessMapper, ApproveProcess> implements IApproveProcessService {
|
private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ofPattern("yyyyMMdd");
|
|
private final StringRedisTemplate redisTemplate;
|
|
private final DailyRedisCounter dailyRedisCounter;
|
|
private final SysDeptMapper sysDeptMapper;
|
private final IApproveNodeService approveNodeService;
|
private final SysUserMapper sysUserMapper;
|
private final ApproveProcessMapper approveProcessMapper;
|
|
@Override
|
public void addApprove(ApproveProcessVO approveProcessVO) throws ParseException {
|
SysUser sysUser = sysUserMapper.selectUserById(approveProcessVO.getApproveUser());
|
SysDept sysDept = sysDeptMapper.selectDeptById(approveProcessVO.getApproveDeptId());
|
String[] split = approveProcessVO.getApproveUserIds().split(",");
|
List<Long> longList = Arrays.stream(split)
|
.map(Long::valueOf) // 将每个 String 转换为 Long
|
.collect(Collectors.toList());
|
List<SysUser> sysUsers = sysUserMapper.selectUserByIds(longList);
|
if(CollectionUtils.isEmpty(sysUsers)) throw new RuntimeException("审核用户不存在");
|
if(sysDept == null) throw new RuntimeException("部门不存在");
|
if(sysUser == null) throw new RuntimeException("申请人不存在");
|
String today = LocalDate.now().format(DATE_FORMAT);
|
Long approveId = dailyRedisCounter.incrementAndGetByDb();
|
String formattedCount = String.format("%03d", approveId);
|
//流程 ID
|
String approveID = today + formattedCount;
|
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
|
ApproveProcess approveProcess = new ApproveProcess();
|
approveProcess.setApproveId(approveID);
|
approveProcess.setApproveUser(approveProcessVO.getApproveUser());
|
approveProcess.setApproveUserName(sysUser.getNickName());
|
approveProcess.setApproveDeptId(approveProcessVO.getApproveDeptId());
|
approveProcess.setApproveDeptName(sysDept.getDeptName());
|
approveProcess.setApproveUserNames(sysUsers.stream().map(SysUser::getNickName).collect(Collectors.joining(",")));
|
approveProcess.setApproveTime(StringUtils.isEmpty(approveProcessVO.getApproveTime()) ? null : dateFormat.parse(approveProcessVO.getApproveTime()));
|
approveProcess.setApproveReason(approveProcessVO.getApproveReason());
|
approveProcess.setApproveOverTime(null);
|
approveProcess.setApproveStatus(0);
|
approveProcess.setApproveDelete(0);
|
approveProcess.setCreateTime(LocalDateTime.now());
|
approveProcess.setTenantId(approveProcessVO.getApproveDeptId());
|
approveProcess.setApproveUserIds(approveProcessVO.getApproveUserIds());
|
approveProcess.setApproveUserCurrentId(longList.get(0));
|
approveProcess.setApproveUserCurrentName(sysUsers
|
.stream()
|
.filter(SysUser -> SysUser.getUserId().equals(longList.get(0)))
|
.collect(Collectors.toList())
|
.get(0)
|
.getNickName());
|
// 设置状态为重新提交
|
if(approveProcessVO.getId() != null){
|
ApproveProcess approveProcess1 = approveProcessMapper.selectById(approveProcessVO.getId());
|
approveProcess1.setApproveStatus(4);
|
approveProcessMapper.updateById(approveProcess1);
|
}
|
save(approveProcess);
|
//初始化审批节点
|
approveNodeService.initApproveNodes(approveProcessVO.getApproveUserIds(),approveID,approveProcessVO.getApproveDeptId());
|
}
|
|
@Override
|
public List<SysDept> selectDeptListByDeptIds(Long[] deptIds) {
|
List<SysDept> sysDeptList =new ArrayList<SysDept>();
|
for (Long deptId : deptIds) {
|
SysDept sysDept = sysDeptMapper.selectDeptById(deptId);
|
sysDeptList.add(sysDept);
|
}
|
return sysDeptList;
|
}
|
|
@Override
|
public IPage<ApproveProcess> listAll(Page page,ApproveProcess approveProcess) {
|
IPage<ApproveProcess> approveProcessIPage = approveProcessMapper.listPage(page,approveProcess);
|
return approveProcessIPage;
|
}
|
|
@Override
|
public void delApprove(Long[] ids) {
|
for (Long id : ids) {
|
UpdateWrapper<ApproveProcess> queryWrapper = new UpdateWrapper<>();
|
queryWrapper.lambda().set(ApproveProcess::getApproveDelete, 1)
|
.eq(ApproveProcess::getApproveId, id);
|
update(queryWrapper);
|
// 删除关联的审批节点
|
approveNodeService.delApproveNodeByApproveId(id);
|
}
|
|
|
}
|
|
@Override
|
public ApproveProcess getApproveById(String id) {
|
LambdaQueryWrapper<ApproveProcess> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.eq(ApproveProcess::getApproveId, id);
|
queryWrapper.eq(ApproveProcess::getApproveDelete, 0);
|
queryWrapper.eq(ApproveProcess::getTenantId, SecurityUtils.getLoginUser().getTenantId());
|
queryWrapper.last("limit 1");
|
ApproveProcess one = getOne(queryWrapper);
|
return one;
|
}
|
|
private final ApproveNodeMapper approveNodeMapper;
|
|
@Override
|
public void updateApproveProcessStatus(ApproveNode approveNode,Integer status) {
|
LambdaQueryWrapper<ApproveProcess> approveProcessLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
approveProcessLambdaQueryWrapper.eq(ApproveProcess::getApproveId, approveNode.getApproveProcessId())
|
.eq(ApproveProcess::getApproveDelete, 0)
|
.eq(ApproveProcess::getTenantId, SecurityUtils.getLoginUser().getTenantId())
|
.last("limit 1");
|
ApproveProcess approveProcess = approveProcessMapper.selectOne(approveProcessLambdaQueryWrapper);
|
if(approveProcess == null) throw new RuntimeException("审批不存在");
|
LambdaQueryWrapper<ApproveNode> approveNodeLambdaQueryWrapper = new LambdaQueryWrapper<>();
|
approveNodeLambdaQueryWrapper.eq(ApproveNode::getApproveProcessId, approveNode.getApproveProcessId())
|
.eq(ApproveNode::getApproveNodeOrder, approveNode.getApproveNodeOrder() + 1)
|
.eq(ApproveNode::getDeleteFlag, 0)
|
.eq(ApproveNode::getTenantId, SecurityUtils.getLoginUser().getTenantId())
|
.last("limit 1");
|
ApproveNode approveNode1 = approveNodeMapper.selectOne(approveNodeLambdaQueryWrapper);
|
approveProcess.setApproveStatus(status);
|
if(approveNode1 != null){
|
approveProcess.setApproveUserCurrentId(approveNode.getApproveNodeUserId());
|
approveProcess.setApproveUserCurrentName(approveNode1.getApproveNodeUser());
|
}
|
updateById(approveProcess);
|
}
|
|
@Override
|
public void updateByApproveId(ApproveGetAndUpdateVo approveGetAndUpdateVo) {
|
ApproveProcess approve = approveProcessMapper.selectById(approveGetAndUpdateVo.getId());
|
approve.setApproveReason(approveGetAndUpdateVo.getApproveReason());
|
updateById(approve);
|
}
|
|
|
}
|
