package com.ruoyi.approve.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.approve.bean.vo.ApproveProcessConfigNodeVo;
|
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.collaborativeApproval.mapper.SealApplicationManagementMapper;
|
import com.ruoyi.collaborativeApproval.pojo.SealApplicationManagement;
|
import com.ruoyi.common.enums.FileNameType;
|
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
|
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
|
import com.ruoyi.common.utils.SecurityUtils;
|
import com.ruoyi.device.mapper.DeviceRepairMapper;
|
import com.ruoyi.device.pojo.DeviceRepair;
|
import com.ruoyi.other.service.impl.TempFileServiceImpl;
|
import com.ruoyi.procurementrecord.utils.StockUtils;
|
import com.ruoyi.project.system.domain.SysUser;
|
import com.ruoyi.project.system.mapper.SysUserMapper;
|
import com.ruoyi.project.system.service.ISysNoticeService;
|
import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;
|
import com.ruoyi.purchase.pojo.PurchaseLedger;
|
import com.ruoyi.quality.mapper.QualityInspectMapper;
|
import com.ruoyi.quality.mapper.QualityInspectParamMapper;
|
import com.ruoyi.quality.mapper.QualityTestStandardMapper;
|
import com.ruoyi.quality.mapper.QualityTestStandardParamMapper;
|
import com.ruoyi.quality.pojo.QualityInspect;
|
import com.ruoyi.quality.pojo.QualityInspectParam;
|
import com.ruoyi.quality.pojo.QualityTestStandard;
|
import com.ruoyi.quality.pojo.QualityTestStandardParam;
|
import com.ruoyi.sales.mapper.CommonFileMapper;
|
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
|
import com.ruoyi.sales.mapper.SalesQuotationMapper;
|
import com.ruoyi.sales.mapper.ShippingInfoMapper;
|
import com.ruoyi.sales.pojo.CommonFile;
|
import com.ruoyi.sales.pojo.SalesLedgerProduct;
|
import com.ruoyi.sales.pojo.SalesQuotation;
|
import com.ruoyi.sales.pojo.ShippingInfo;
|
import com.ruoyi.sales.service.impl.CommonFileServiceImpl;
|
import lombok.RequiredArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.CollectionUtils;
|
|
import java.io.IOException;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.Date;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
@Service
|
@RequiredArgsConstructor
|
public class ApproveNodeServiceImpl extends ServiceImpl<ApproveNodeMapper, ApproveNode> implements IApproveNodeService {
|
|
private final ApproveNodeMapper approveNodeMapper;
|
private final ApproveProcessMapper approveProcessMapper;
|
private final SysUserMapper sysUserMapper;
|
private final TempFileServiceImpl tempFileService;
|
private final ISysNoticeService sysNoticeService;
|
private final CommonFileMapper fileMapper;
|
private final DeviceRepairMapper deviceRepairMapper;
|
private final PurchaseLedgerMapper purchaseLedgerMapper;
|
private final SalesQuotationMapper salesQuotationMapper;
|
private final ShippingInfoMapper shippingInfoMapper;
|
private final CommonFileServiceImpl commonFileService;
|
private final StockUtils stockUtils;
|
private final SalesLedgerProductMapper salesLedgerProductMapper;
|
private final QualityInspectMapper qualityInspectMapper;
|
private final QualityTestStandardMapper qualityTestStandardMapper;
|
private final QualityTestStandardParamMapper qualityTestStandardParamMapper;
|
private final QualityInspectParamMapper qualityInspectParamMapper;
|
private final SealApplicationManagementMapper sealApplicationManagementMapper;
|
|
|
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 = approveProcessMapper.selectOne(queryWrapper);
|
return one;
|
}
|
|
@Override
|
public void initApproveNodes(String approveUserIds, String approveID, Long tenantId) {
|
if (approveUserIds == null || approveUserIds.isEmpty()) {
|
return;
|
}
|
List<ApproveProcessConfigNodeVo> config = new ArrayList<>();
|
String[] ids = approveUserIds.split(",");
|
for (int i = 0; i < ids.length; i++) {
|
if (ids[i] == null || ids[i].trim().isEmpty()) {
|
continue;
|
}
|
ApproveProcessConfigNodeVo vo = new ApproveProcessConfigNodeVo();
|
vo.setNodeOrder(i + 1);
|
vo.setApproverId(Long.parseLong(ids[i].trim()));
|
vo.setApproveMode("or");
|
config.add(vo);
|
}
|
initApproveNodes(config, approveID, tenantId);
|
}
|
|
@Override
|
public void initApproveNodes(List<ApproveProcessConfigNodeVo> config, String approveID, Long tenantId) {
|
Long userId = SecurityUtils.getLoginUser().getUser().getUserId();
|
// 按节点顺序分组，保证同一节点的多审批人写入相同 approveNodeOrder
|
Map<Integer, List<ApproveProcessConfigNodeVo>> groups = new LinkedHashMap<>();
|
for (ApproveProcessConfigNodeVo vo : config) {
|
if (vo.getApproverId() == null) {
|
continue;
|
}
|
int order = vo.getNodeOrder() == null ? groups.size() + 1 : vo.getNodeOrder();
|
groups.computeIfAbsent(order, k -> new ArrayList<>()).add(vo);
|
}
|
for (Map.Entry<Integer, List<ApproveProcessConfigNodeVo>> entry : groups.entrySet()) {
|
Integer order = entry.getKey();
|
String mode = entry.getValue().get(0).getApproveMode();
|
if (mode == null || mode.isEmpty()) {
|
mode = "or";
|
}
|
List<Long> seenIds = new ArrayList<>();
|
for (ApproveProcessConfigNodeVo vo : entry.getValue()) {
|
Long approverId = vo.getApproverId();
|
if (seenIds.contains(approverId)) {
|
continue;
|
}
|
seenIds.add(approverId);
|
SysUser sysUser = sysUserMapper.selectUserById(approverId);
|
if (sysUser == null) {
|
continue;
|
}
|
ApproveNode approveNode = new ApproveNode();
|
approveNode.setApproveProcessId(approveID);
|
approveNode.setApproveNodeOrder(order);
|
approveNode.setApproveMode(mode);
|
approveNode.setApproveNodeUser(sysUser.getNickName());
|
approveNode.setApproveNodeUserId(sysUser.getUserId());
|
approveNode.setApproveNodeTime(new Date());
|
approveNode.setApproveNodeStatus(0);
|
approveNode.setTenantId(tenantId);
|
approveNode.setDeleteFlag(0);
|
approveNode.setCreateUser(userId);
|
approveNode.setUpdateUser(userId);
|
approveNode.setCreateTime(LocalDateTime.now());
|
approveNode.setUpdateTime(LocalDateTime.now());
|
approveNodeMapper.insert(approveNode);
|
}
|
}
|
}
|
|
@Override
|
public List<ApproveNode> details(String id) {
|
LambdaQueryWrapper<ApproveNode> queryWrapper = new LambdaQueryWrapper<>();
|
queryWrapper.eq(ApproveNode::getApproveProcessId, id);
|
queryWrapper.eq(ApproveNode::getDeleteFlag, 0);
|
List<ApproveNode> list = list(queryWrapper);
|
// 按 approveNodeOrder 升序、同节点按 id 升序，保证同节点多审批人顺序稳定
|
list.sort(Comparator.comparingInt(ApproveNode::getApproveNodeOrder).thenComparingLong(ApproveNode::getId));
|
bindNodeUrl(list);
|
ApproveProcess approveProcess = getApproveById(id);
|
if (approveProcess == null || approveProcess.getApproveStatus() == 2
|
|| approveProcess.getApproveStatus() == 3 || approveProcess.getApproveStatus() == 4) {
|
// 流程已完成/驳回/重新提交，全部只读
|
return list;
|
}
|
Integer currentOrder = pendingOrder(id);
|
Long loginUserId = SecurityUtils.getLoginUser().getUser().getUserId();
|
boolean admin = SecurityUtils.isAdmin(loginUserId);
|
boolean ishenSet = false;
|
for (ApproveNode approveNode : list) {
|
// 管理员不受审批人限制：代审当前节点首个待审记录（整节点代审由 updateApproveNode 完成）
|
if (approveNode.getApproveNodeOrder().equals(currentOrder)
|
&& approveNode.getApproveNodeStatus() == 0
|
&& (admin || approveNode.getApproveNodeUserId().equals(loginUserId))
|
&& !ishenSet) {
|
approveNode.setIsShen(true);
|
ishenSet = true;
|
}
|
}
|
return list;
|
}
|
|
/**
|
* 业务回调：按审批类型更新对应业务单据状态
|
* status: 1=审核中(会签部分通过), 2=审核完成(同意), 3=审核未通过(拒绝)
|
*/
|
private void applyBusinessStatus(ApproveProcess approveProcess, Integer status) {
|
// 采购审批
|
if (approveProcess.getApproveType().equals(5)) {
|
PurchaseLedger purchaseLedger = purchaseLedgerMapper.selectOne(new LambdaQueryWrapper<PurchaseLedger>()
|
.eq(PurchaseLedger::getPurchaseContractNumber, approveProcess.getApproveReason())
|
.last("limit 1"));
|
if (purchaseLedger != null) {
|
if (status.equals(2)) {
|
// 同意：生成质检/入库
|
purchaseLedger.setApprovalStatus(3);
|
List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectList(new QueryWrapper<SalesLedgerProduct>()
|
.lambda().eq(SalesLedgerProduct::getSalesLedgerId, purchaseLedger.getId()).eq(SalesLedgerProduct::getType, 2));
|
for (SalesLedgerProduct salesLedgerProduct : salesLedgerProducts) {
|
if (salesLedgerProduct.getIsChecked()) {
|
addQualityInspect(purchaseLedger, salesLedgerProduct);
|
} else {
|
// 直接入库
|
stockUtils.addStock(salesLedgerProduct.getProductModelId(), salesLedgerProduct.getQuantity(),
|
StockInQualifiedRecordTypeEnum.PURCHASE_STOCK_IN.getCode(), purchaseLedger.getId(), "-", "-", "-");
|
}
|
}
|
} else if (status.equals(3)) {
|
// 拒绝
|
purchaseLedger.setApprovalStatus(4);
|
} else if (status.equals(1)) {
|
// 审核中
|
purchaseLedger.setApprovalStatus(2);
|
}
|
purchaseLedgerMapper.updateById(purchaseLedger);
|
}
|
}
|
// 销售报价状态修改
|
if (approveProcess.getApproveType().equals(6)) {
|
SalesQuotation salesQuote = salesQuotationMapper.selectOne(new LambdaQueryWrapper<SalesQuotation>()
|
.eq(SalesQuotation::getQuotationNo, approveProcess.getApproveReason())
|
.last("limit 1"));
|
if (salesQuote != null) {
|
if (status.equals(2)) {
|
salesQuote.setStatus("通过");
|
} else if (status.equals(3)) {
|
salesQuote.setStatus("拒绝");
|
} else if (status.equals(1)) {
|
salesQuote.setStatus("审核中");
|
}
|
salesQuotationMapper.updateById(salesQuote);
|
}
|
}
|
// 出库审批状态修改
|
if (approveProcess.getApproveType().equals(7)) {
|
String[] split = approveProcess.getApproveReason().split(":");
|
if (split.length > 1) {
|
ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()
|
.eq(ShippingInfo::getShippingNo, split[1])
|
.orderByDesc(ShippingInfo::getCreateTime)
|
.last("limit 1"));
|
if (shippingInfo != null) {
|
if (status.equals(2)) {
|
shippingInfo.setStatus("审核通过");
|
} else if (status.equals(3)) {
|
shippingInfo.setStatus("审核拒绝");
|
} else if (status.equals(1)) {
|
shippingInfo.setStatus("审核中");
|
}
|
shippingInfoMapper.updateById(shippingInfo);
|
}
|
}
|
}
|
// 用印审批状态修改
|
if (approveProcess.getApproveType().equals(9)) {
|
SealApplicationManagement seal = sealApplicationManagementMapper.selectOne(new LambdaQueryWrapper<SealApplicationManagement>()
|
.eq(SealApplicationManagement::getApproveProcessId, approveProcess.getId())
|
.last("limit 1"));
|
if (seal != null) {
|
if (status.equals(2)) {
|
seal.setStatus("approved");
|
} else if (status.equals(3)) {
|
seal.setStatus("rejected");
|
} else if (status.equals(1)) {
|
seal.setStatus("pending");
|
}
|
sealApplicationManagementMapper.updateById(seal);
|
}
|
}
|
}
|
|
/**
|
* 当前待审批节点序号：所有未审批节点中最小的 approveNodeOrder
|
*/
|
private Integer pendingOrder(String approveId) {
|
return list(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getApproveProcessId, approveId)
|
.eq(ApproveNode::getDeleteFlag, 0)
|
.eq(ApproveNode::getApproveNodeStatus, 0))
|
.stream()
|
.map(ApproveNode::getApproveNodeOrder)
|
.min(Integer::compareTo)
|
.orElse(null);
|
}
|
|
/**
|
* 查询指定流程指定节点的全部审批节点（同节点多审批人，按 id 升序）
|
*/
|
private List<ApproveNode> nodesByOrder(String approveId, Integer order) {
|
return list(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getApproveProcessId, approveId)
|
.eq(ApproveNode::getApproveNodeOrder, order)
|
.eq(ApproveNode::getDeleteFlag, 0)
|
.orderByAsc(ApproveNode::getId));
|
}
|
|
/**
|
* 设置流程当前节点待审人（多值逗号分隔，兼容旧的单值字段）
|
*/
|
private void setCurrentApprovers(ApproveProcess approveProcess, List<ApproveNode> nodes) {
|
if (nodes == null || nodes.isEmpty()) {
|
approveProcess.setApproveUserCurrentIds(null);
|
approveProcess.setApproveUserCurrentNames(null);
|
approveProcess.setApproveUserCurrentId(null);
|
approveProcess.setApproveUserCurrentName(null);
|
return;
|
}
|
approveProcess.setApproveUserCurrentIds(nodes.stream().map(ApproveNode::getApproveNodeUserId)
|
.map(String::valueOf).collect(Collectors.joining(",")));
|
approveProcess.setApproveUserCurrentNames(nodes.stream().map(ApproveNode::getApproveNodeUser)
|
.collect(Collectors.joining(",")));
|
approveProcess.setApproveUserCurrentId(nodes.get(0).getApproveNodeUserId());
|
approveProcess.setApproveUserCurrentName(nodes.get(0).getApproveNodeUser());
|
}
|
|
/**
|
* 通知当前节点全部待审人
|
*/
|
private void notifyApproveUsers(List<Long> userIds, ApproveProcess approveProcess) {
|
if (userIds == null || userIds.isEmpty()) {
|
return;
|
}
|
List<Long> ids = userIds.stream().distinct().collect(Collectors.toList());
|
if (approveProcess.getApproveType() == 8) {
|
sysNoticeService.simpleNoticeByUser(approveProcessType(approveProcess.getApproveType()),
|
approveProcess.getApproveId() + "流程编号的审批需要您审核!!!!!",
|
ids,
|
"/safeProduction/safeWorkApproval?approveType=" + approveProcess.getApproveType() + "&approveId=" + approveProcess.getApproveId());
|
} else {
|
sysNoticeService.simpleNoticeByUser(approveProcessType(approveProcess.getApproveType()),
|
approveProcess.getApproveId() + "流程编号的审批需要您审核!!!!!",
|
ids,
|
"/collaborativeApproval/approvalProcess?approveType=" + approveProcess.getApproveType() + "&approveId=" + approveProcess.getApproveId());
|
}
|
}
|
|
/**
|
* 填充审批节点附件 url
|
*/
|
private void bindNodeUrl(List<ApproveNode> nodes) {
|
if (CollectionUtils.isEmpty(nodes)) {
|
return;
|
}
|
for (ApproveNode approveNode : nodes) {
|
List<CommonFile> commonFiles = fileMapper.selectList(new LambdaQueryWrapper<CommonFile>()
|
.eq(CommonFile::getCommonId, approveNode.getId())
|
.eq(CommonFile::getType, FileNameType.ApproveNode.getValue()));
|
if (!CollectionUtils.isEmpty(commonFiles)) {
|
approveNode.setUrl(commonFiles.get(0).getUrl());
|
}
|
}
|
}
|
|
/**
|
* 临时附件迁移为正式附件
|
*/
|
private void bindNodeFiles(ApproveNode approveNode, List<String> tempFileIds) throws IOException {
|
if (!CollectionUtils.isEmpty(tempFileIds) && approveNode.getApproveNodeStatus() != null
|
&& approveNode.getApproveNodeStatus() == 1) {
|
tempFileService.migrateTempFilesToFormal(approveNode.getId(), tempFileIds, FileNameType.ApproveNode.getValue());
|
}
|
}
|
|
@Override
|
public void updateApproveNode(ApproveNode approveNode) throws IOException {
|
ApproveNode db = approveNodeMapper.selectById(approveNode.getId());
|
if (db == null || db.getDeleteFlag() != null && db.getDeleteFlag() == 1) {
|
throw new RuntimeException("审批节点不存在");
|
}
|
if (db.getApproveNodeStatus() != null && db.getApproveNodeStatus() != 0) {
|
throw new RuntimeException("该节点已审批，请勿重复操作");
|
}
|
Long loginUserId = SecurityUtils.getLoginUser().getUser().getUserId();
|
boolean admin = SecurityUtils.isAdmin(loginUserId);
|
// 管理员不受审批人限制
|
if (!admin && !db.getApproveNodeUserId().equals(loginUserId)) {
|
throw new RuntimeException("无权审批该节点");
|
}
|
ApproveProcess approveProcess = getApproveById(db.getApproveProcessId());
|
if (approveProcess == null) {
|
throw new RuntimeException("审批流程不存在");
|
}
|
if (approveProcess.getApproveStatus() == null
|
|| (approveProcess.getApproveStatus() != 0 && approveProcess.getApproveStatus() != 1)) {
|
throw new RuntimeException("当前流程状态不允许审批");
|
}
|
Integer curOrder = pendingOrder(db.getApproveProcessId());
|
if (!db.getApproveNodeOrder().equals(curOrder)) {
|
throw new RuntimeException("尚未轮到该节点审批");
|
}
|
|
db.setApproveNodeStatus(approveNode.getApproveNodeStatus());
|
db.setApproveNodeReason(approveNode.getApproveNodeReason());
|
db.setApproveNodeRemark(approveNode.getApproveNodeRemark());
|
db.setApproveNodeTime(new Date());
|
db.setUpdateUser(loginUserId);
|
approveNodeMapper.updateById(db);
|
|
// 拒绝：一票否决，立即驳回整个流程
|
if (db.getApproveNodeStatus() != null && db.getApproveNodeStatus() == 2) {
|
approveProcess.setApproveStatus(3);
|
approveProcess.setApproveOverTime(new Date());
|
approveProcessMapper.updateById(approveProcess);
|
applyBusinessStatus(approveProcess, 3);
|
bindNodeFiles(db, approveNode.getTempFileIds());
|
return;
|
}
|
|
String mode = db.getApproveMode();
|
if (mode == null || mode.isEmpty()) {
|
mode = "or";
|
}
|
List<ApproveNode> sameOrder = nodesByOrder(db.getApproveProcessId(), db.getApproveNodeOrder());
|
// 管理员代审：当前节点其余待审记录一并通过
|
if (admin) {
|
for (ApproveNode n : sameOrder) {
|
if (n.getApproveNodeStatus() == null || n.getApproveNodeStatus() == 0) {
|
n.setApproveNodeStatus(1);
|
n.setApproveNodeRemark("管理员代审通过");
|
n.setApproveNodeTime(new Date());
|
approveNodeMapper.updateById(n);
|
}
|
}
|
}
|
boolean released;
|
if ("and".equals(mode)) {
|
// 会签：节点内所有人均同意才放行
|
released = sameOrder.stream().allMatch(n -> n.getApproveNodeStatus() != null && n.getApproveNodeStatus() == 1);
|
} else {
|
// 或签：节点内任一同意即放行
|
released = sameOrder.stream().anyMatch(n -> n.getApproveNodeStatus() != null && n.getApproveNodeStatus() == 1);
|
}
|
|
// 会签未放行：节点内仍有待审人，流程保持审核中
|
if (!released) {
|
List<ApproveNode> pending = sameOrder.stream()
|
.filter(n -> n.getApproveNodeStatus() == null || n.getApproveNodeStatus() == 0)
|
.collect(Collectors.toList());
|
approveProcess.setApproveStatus(1);
|
setCurrentApprovers(approveProcess, pending);
|
approveProcessMapper.updateById(approveProcess);
|
applyBusinessStatus(approveProcess, 1);
|
bindNodeFiles(db, approveNode.getTempFileIds());
|
return;
|
}
|
|
// 或签放行：同节点其余未审批记录标记为自动同意
|
if (!"and".equals(mode)) {
|
for (ApproveNode n : sameOrder) {
|
if (n.getApproveNodeStatus() == null || n.getApproveNodeStatus() == 0) {
|
n.setApproveNodeStatus(1);
|
n.setApproveNodeRemark("或签：其他审批人已通过");
|
n.setApproveNodeTime(new Date());
|
approveNodeMapper.updateById(n);
|
}
|
}
|
}
|
|
List<ApproveNode> next = nodesByOrder(db.getApproveProcessId(), db.getApproveNodeOrder() + 1).stream()
|
.filter(n -> n.getApproveNodeStatus() == null || n.getApproveNodeStatus() == 0)
|
.collect(Collectors.toList());
|
if (next.isEmpty()) {
|
// 最后节点放行：流程完成
|
approveProcess.setApproveStatus(2);
|
approveProcess.setApproveOverTime(new Date());
|
setCurrentApprovers(approveProcess, new ArrayList<>());
|
approveProcessMapper.updateById(approveProcess);
|
applyBusinessStatus(approveProcess, 2);
|
} else {
|
// 流转下一节点
|
approveProcess.setApproveStatus(1);
|
setCurrentApprovers(approveProcess, next);
|
approveProcessMapper.updateById(approveProcess);
|
applyBusinessStatus(approveProcess, 1);
|
notifyApproveUsers(next.stream().map(ApproveNode::getApproveNodeUserId).collect(Collectors.toList()), approveProcess);
|
}
|
bindNodeFiles(db, approveNode.getTempFileIds());
|
}
|
|
@Override
|
public void delApproveNodeByApproveId(String id) {
|
List<ApproveNode> approveNodes = approveNodeMapper.selectList(new LambdaQueryWrapper<ApproveNode>()
|
.eq(ApproveNode::getApproveProcessId, id));
|
UpdateWrapper<ApproveNode> queryWrapper = new UpdateWrapper<>();
|
queryWrapper.lambda().set(ApproveNode::getDeleteFlag, 1)
|
.eq(ApproveNode::getApproveProcessId, id);
|
update(queryWrapper);
|
// 删除附件
|
for (ApproveNode approveNode : approveNodes) {
|
commonFileService.deleteByBusinessId(approveNode.getId(), FileNameType.ApproveNode.getValue());
|
}
|
}
|
|
//审批类型获取(与前端页面对应)
|
private String approveProcessType(Integer approveType){
|
switch (approveType){
|
case 1:
|
return "公出管理";
|
case 2:
|
return "请假管理";
|
case 3:
|
return "出差管理";
|
case 4:
|
return "报销管理";
|
case 5:
|
return "采购审批";
|
case 6:
|
return "报价审批";
|
case 7:
|
return "发货审批";
|
case 8:
|
return "危险作业审批";
|
case 9:
|
return "用印审批";
|
}
|
return null;
|
}
|
|
private void addQualityInspect(PurchaseLedger purchaseLedger, SalesLedgerProduct saleProduct) {
|
QualityInspect qualityInspect = new QualityInspect();
|
qualityInspect.setInspectType(0);
|
qualityInspect.setSupplier(purchaseLedger.getSupplierName());
|
qualityInspect.setPurchaseLedgerId(purchaseLedger.getId());
|
qualityInspect.setProductId(saleProduct.getProductId());
|
qualityInspect.setProductName(saleProduct.getProductCategory());
|
qualityInspect.setModel(saleProduct.getSpecificationModel());
|
qualityInspect.setProductModelId(saleProduct.getProductModelId());
|
qualityInspect.setUnit(saleProduct.getUnit());
|
qualityInspect.setQuantity(saleProduct.getQuantity());
|
qualityInspectMapper.insert(qualityInspect);
|
List<QualityTestStandard> qualityTestStandard = qualityTestStandardMapper.getQualityTestStandardByProductId(saleProduct.getProductId(), 0,null);
|
if (qualityTestStandard.size()>0){
|
qualityInspect.setTestStandardId(qualityTestStandard.get(0).getId());
|
qualityInspectMapper.updateById(qualityInspect);
|
qualityTestStandardParamMapper.selectList(Wrappers.<QualityTestStandardParam>lambdaQuery()
|
.eq(QualityTestStandardParam::getTestStandardId,qualityTestStandard.get(0).getId()))
|
.forEach(qualityTestStandardParam -> {
|
QualityInspectParam param = new QualityInspectParam();
|
com.ruoyi.common.utils.bean.BeanUtils.copyProperties(qualityTestStandardParam, param);
|
param.setId(null);
|
param.setInspectId(qualityInspect.getId());
|
qualityInspectParamMapper.insert(param);
|
});
|
}
|
}
|
|
}
|
