feat：采购批量审核-质检-入库

liding

14 小时以前 8beb176e14312b8e7ca43a25f8ec1386157502f9

 src/main/java/com/ruoyi/purchase/service/impl/PurchaseLedgerServiceImpl.java

@@ -6,8 +6,12 @@
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.ApproveProcessVO;
import com.ruoyi.approve.bean.dto.ApprovalInstanceDto;
import com.ruoyi.approve.mapper.ApprovalTemplateMapper;
import com.ruoyi.approve.pojo.ApprovalInstance;
import com.ruoyi.approve.pojo.ApprovalTemplate;
import com.ruoyi.approve.pojo.ApproveProcess;
import com.ruoyi.approve.service.ApprovalInstanceService;
import com.ruoyi.approve.service.impl.ApproveProcessServiceImpl;
import com.ruoyi.basic.enums.ApplicationTypeEnum;
import com.ruoyi.basic.enums.RecordTypeEnum;
@@ -18,16 +22,21 @@
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.basic.pojo.SupplierManage;
import com.ruoyi.basic.utils.FileUtil;
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.enums.ApprovalStatusEnum;
import com.ruoyi.common.enums.ReviewStatusEnum;
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.security.LoginUser;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.other.mapper.TempFileMapper;
import com.ruoyi.procurementrecord.mapper.ProcurementRecordMapper;
import com.ruoyi.procurementrecord.pojo.ProcurementRecordStorage;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.purchase.dto.PurchaseLedgerDto;
@@ -44,13 +53,15 @@
import com.ruoyi.quality.pojo.QualityInspectParam;
import com.ruoyi.quality.pojo.QualityTestStandard;
import com.ruoyi.quality.pojo.QualityTestStandardParam;
import com.ruoyi.quality.service.IQualityInspectService;
import com.ruoyi.sales.mapper.CommonFileMapper;
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
import com.ruoyi.sales.pojo.CommonFile;
import com.ruoyi.sales.pojo.SalesLedger;
import com.ruoyi.sales.pojo.SalesLedgerProduct;
import com.ruoyi.sales.service.impl.CommonFileServiceImpl;
import com.ruoyi.stock.pojo.StockInRecord;
import com.ruoyi.stock.service.StockInRecordService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
@@ -100,6 +111,11 @@
    private final ApproveProcessServiceImpl approveProcessService;
    private final ProcurementRecordMapper procurementRecordStorageMapper;
    private final FileUtil fileUtil;
    private final ApprovalInstanceService approvalInstanceService;
    private final IQualityInspectService qualityInspectService;
    private final StockInRecordService stockInRecordService;
    private final StockUtils stockUtils;
    private final ApprovalTemplateMapper approvalTemplateMapper;

    @Override
    public List<PurchaseLedger> selectPurchaseLedgerList(PurchaseLedger purchaseLedger) {
@@ -174,6 +190,188 @@
        return 1;
    }

    @Override
    public R batchInsertPurchaseSteps(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return R.fail("请选择采购台账");
        }

        List<Long> distinctIds = ids.stream()
                .filter(Objects::nonNull)
                .distinct()
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(distinctIds)) {
            return R.fail("请选择采购台账");
        }

        PurchaseLedgerDto queryDto = new PurchaseLedgerDto();
        queryDto.setIds(distinctIds);
        IPage<PurchaseLedgerDto> pageResult = this.selectPurchaseLedgerListPage(
                new com.baomidou.mybatisplus.extension.plugins.pagination.Page<>(1, distinctIds.size()),
                queryDto
        );
        List<PurchaseLedgerDto> ledgerDtos = pageResult == null || pageResult.getRecords() == null
                ? Collections.emptyList()
                : pageResult.getRecords();

        Map<Long, PurchaseLedgerDto> ledgerDtoMap = ledgerDtos.stream()
                .filter(item -> item.getId() != null)
                .collect(Collectors.toMap(PurchaseLedgerDto::getId, item -> item, (left, right) -> left, LinkedHashMap::new));

        List<Map<String, Object>> details = new ArrayList<>();
        int successCount = 0;
        int skipCount = 0;
        int failCount = 0;
        int autoApprovedCount = 0;

        for (Long id : distinctIds) {
            Map<String, Object> detail = new LinkedHashMap<>();
            detail.put("purchaseLedgerId", id);
            PurchaseLedgerDto purchaseLedgerDto = ledgerDtoMap.get(id);
            if (purchaseLedgerDto == null) {
                failCount++;
                detail.put("status", "FAIL");
                detail.put("message", "采购台账不存在或未查询到");
                details.add(detail);
                continue;
            }

            detail.put("purchaseContractNumber", purchaseLedgerDto.getPurchaseContractNumber());
            detail.put("approvalStatus", purchaseLedgerDto.getApprovalStatus());
            detail.put("stockInStatus", purchaseLedgerDto.getStockInStatus());

            if (ApprovalStatusEnum.REJECTED.getCode().equals(purchaseLedgerDto.getApprovalStatus())) {
                skipCount++;
                detail.put("status", "SKIP");
                detail.put("message", "采购单已驳回");
                details.add(detail);
                continue;
            }

            if ("完全入库".equals(purchaseLedgerDto.getStockInStatus())) {
                skipCount++;
                detail.put("status", "SKIP");
                detail.put("message", "采购单已完全入库");
                details.add(detail);
                continue;
            }

            try {
                PurchaseLedger purchaseLedger = purchaseLedgerMapper.selectById(id);
                if (purchaseLedger == null) {
                    failCount++;
                    detail.put("status", "FAIL");
                    detail.put("message", "采购台账不存在");
                    details.add(detail);
                    continue;
                }

                if (!ApprovalStatusEnum.APPROVED.getCode().equals(purchaseLedger.getApprovalStatus())) {
                    ApprovalInstance approvalInstance = approvalInstanceService.getOne(
                            Wrappers.<ApprovalInstance>lambdaQuery()
                                    .eq(ApprovalInstance::getBusinessId, purchaseLedger.getId())
                                    .eq(ApprovalInstance::getBusinessType, 5L)
                                    .eq(ApprovalInstance::getDeleted, 0)
                                    .orderByDesc(ApprovalInstance::getId)
                                    .last("limit 1")
                    );
                    if (approvalInstance == null) {
                        failCount++;
                        detail.put("status", "FAIL");
                        detail.put("message", "未找到对应的采购审批实例");
                        details.add(detail);
                        continue;
                    }

                    if ("APPROVED".equals(approvalInstance.getStatus())
                            && !ApprovalStatusEnum.APPROVED.getCode().equals(purchaseLedger.getApprovalStatus())) {
                        purchaseLedger.setApprovalStatus(ApprovalStatusEnum.APPROVED.getCode());
                        purchaseLedgerMapper.updateById(purchaseLedger);
                    } else if (!"APPROVED".equals(approvalInstance.getStatus())) {
                        R autoApproveResult = approvalInstanceService.autoApprove(approvalInstance.getId());
                        if (autoApproveResult == null || !R.isSuccess(autoApproveResult)) {
                            failCount++;
                            detail.put("status", "FAIL");
                            detail.put("message", autoApproveResult == null ? "采购审批自动通过失败" : autoApproveResult.getMsg());
                            details.add(detail);
                            continue;
                        }
                        autoApprovedCount++;
                    }

                    purchaseLedger = purchaseLedgerMapper.selectById(id);
                    if (purchaseLedger == null || !ApprovalStatusEnum.APPROVED.getCode().equals(purchaseLedger.getApprovalStatus())) {
                        failCount++;
                        detail.put("status", "FAIL");
                        detail.put("message", "采购单审批状态未更新为已通过");
                        details.add(detail);
                        continue;
                    }
                }

                List<SalesLedgerProduct> products = salesLedgerProductMapper.selectList(
                        Wrappers.<SalesLedgerProduct>lambdaQuery()
                                .eq(SalesLedgerProduct::getSalesLedgerId, purchaseLedger.getId())
                                .eq(SalesLedgerProduct::getType, 2)
                                .orderByAsc(SalesLedgerProduct::getId)
                );
                if (CollectionUtils.isEmpty(products)) {
                    skipCount++;
                    detail.put("status", "SKIP");
                    detail.put("message", "采购单没有产品明细");
                    details.add(detail);
                    continue;
                }

                int processedProductCount = 0;
                int skippedProductCount = 0;
                int failedProductCount = 0;
                for (SalesLedgerProduct product : products) {
                    try {
                        boolean processed;
                        if (Boolean.TRUE.equals(product.getIsChecked())) {
                            processed = processPurchaseQualityProduct(purchaseLedger, product);
                        } else {
                            processed = processPurchaseDirectProduct(purchaseLedger, product);
                        }
                        if (processed) {
                            processedProductCount++;
                        } else {
                            skippedProductCount++;
                        }
                    } catch (Exception ex) {
                        failedProductCount++;
                        log.error("批量推进采购台账失败, purchaseLedgerId={}, productId={}, productModelId={}",
                                purchaseLedger.getId(), product.getId(), product.getProductModelId(), ex);
                    }
                }

                successCount++;
                detail.put("status", failedProductCount > 0 ? "PARTIAL" : "SUCCESS");
                detail.put("processedProductCount", processedProductCount);
                detail.put("skippedProductCount", skippedProductCount);
                detail.put("failedProductCount", failedProductCount);
                detail.put("message", failedProductCount > 0 ? "部分产品处理失败" : "处理完成");
                details.add(detail);
            } catch (Exception ex) {
                failCount++;
                detail.put("status", "FAIL");
                detail.put("message", ex.getMessage());
                details.add(detail);
                log.error("批量推进采购台账失败, purchaseLedgerId={}", id, ex);
            }
        }

        Map<String, Object> summary = new LinkedHashMap<>();
        summary.put("totalCount", distinctIds.size());
        summary.put("successCount", successCount);
        summary.put("skipCount", skipCount);
        summary.put("failCount", failCount);
        summary.put("autoApprovedCount", autoApprovedCount);
        summary.put("details", details);
        return R.ok(summary, "批量推进采购步骤完成");
    }


    public void addQualityInspect(PurchaseLedger purchaseLedger, SalesLedgerProduct saleProduct) {
        QualityInspect qualityInspect = new QualityInspect();
@@ -199,7 +397,219 @@
                        param.setId(null);
                        param.setInspectId(qualityInspect.getId());
                        qualityInspectParamMapper.insert(param);
                    });
            });
        }
    }

    private boolean processPurchaseQualityProduct(PurchaseLedger purchaseLedger, SalesLedgerProduct product) {
        if (purchaseLedger == null || product == null || product.getProductModelId() == null) {
            return false;
        }

        QualityInspect qualityInspect = findLatestPurchaseQualityInspect(purchaseLedger.getId(), product.getProductModelId());
        if (qualityInspect == null) {
            addQualityInspect(purchaseLedger, product);
            qualityInspect = findLatestPurchaseQualityInspect(purchaseLedger.getId(), product.getProductModelId());
        }
        if (qualityInspect == null) {
            return false;
        }

        LocalDateTime purchaseInspectTime = toStartOfDayPlusDays(purchaseLedger.getEntryDate(), 1);
        if (purchaseInspectTime != null && (qualityInspect.getCheckTime() == null
                || !DateUtils.toLocalDate(qualityInspect.getCheckTime()).equals(purchaseInspectTime.toLocalDate()))) {
            qualityInspect.setCheckTime(DateUtils.toDate(purchaseInspectTime.toLocalDate()));
            qualityInspectMapper.updateById(qualityInspect);
        }

        List<StockInRecord> stockRecords = findQualityStockRecords(qualityInspect.getId(), product.getProductModelId());
        if (hasApprovedStockRecord(stockRecords)) {
            return true;
        }

        if (!Integer.valueOf(1).equals(qualityInspect.getInspectState())) {
            R autoSubmitResult = qualityInspectService.autoSubmit(qualityInspect.getId());
            if (autoSubmitResult == null || !R.isSuccess(autoSubmitResult)) {
                return false;
            }
            qualityInspect = qualityInspectMapper.selectById(qualityInspect.getId());
        }

        stockRecords = findQualityStockRecords(qualityInspect.getId(), product.getProductModelId());
        if (CollectionUtils.isEmpty(stockRecords)
                && qualityInspect.getQualifiedQuantity() != null
                && qualityInspect.getQualifiedQuantity().compareTo(BigDecimal.ZERO) > 0) {
            stockUtils.addStockWithBatchNo(
                    product.getProductModelId(),
                    qualityInspect.getQualifiedQuantity(),
                    StockInQualifiedRecordTypeEnum.CUSTOMIZATION_UNSTOCK_OUT.getCode(),
                    qualityInspect.getId(),
                    null,
                    purchaseInspectTime == null ? null : purchaseInspectTime.plusDays(1)
            );
            stockRecords = findQualityStockRecords(qualityInspect.getId(), product.getProductModelId());
        }

        StockInRecord targetStockRecord = findLatestUnapprovedStockRecord(stockRecords);
        if (targetStockRecord == null) {
            return false;
        }

        LocalDateTime qualityStockCreateTime = resolveQualityStockCreateTime(qualityInspect);
        if (qualityStockCreateTime != null && (targetStockRecord.getCreateTime() == null
                || !qualityStockCreateTime.equals(targetStockRecord.getCreateTime()))) {
            targetStockRecord.setCreateTime(qualityStockCreateTime);
            stockInRecordService.updateById(targetStockRecord);
        }

        approveStockRecords(Collections.singletonList(targetStockRecord));
        stockRecords = findQualityStockRecords(qualityInspect.getId(), product.getProductModelId());
        return hasApprovedStockRecord(stockRecords);
    }

    private boolean processPurchaseDirectProduct(PurchaseLedger purchaseLedger, SalesLedgerProduct product) {
        if (purchaseLedger == null || product == null || product.getProductModelId() == null) {
            return false;
        }
        if (product.getQuantity() == null) {
            return false;
        }
        if (!StringUtils.hasText(purchaseLedger.getPurchaseContractNumber())) {
            return false;
        }

        LocalDateTime stockCreateTime = toStartOfDayPlusDays(purchaseLedger.getEntryDate(), 1);

        List<StockInRecord> stockRecords = findDirectStockRecords(purchaseLedger.getId(), purchaseLedger.getPurchaseContractNumber(), product.getProductModelId(), product.getId());
        if (hasApprovedStockRecord(stockRecords)) {
            return true;
        }

        if (CollectionUtils.isEmpty(stockRecords)) {
            stockUtils.addStockWithBatchNo(
                    product.getProductModelId(),
                    product.getQuantity(),
                    StockInQualifiedRecordTypeEnum.PURCHASE_STOCK_IN.getCode(),
                    purchaseLedger.getId(),
                    purchaseLedger.getPurchaseContractNumber() + "-" + product.getId(),
                    stockCreateTime
            );
            stockRecords = findDirectStockRecords(purchaseLedger.getId(), purchaseLedger.getPurchaseContractNumber(), product.getProductModelId(), product.getId());
        }

        if (CollectionUtils.isEmpty(stockRecords)) {
            return false;
        }

        StockInRecord targetStockRecord = findLatestUnapprovedStockRecord(stockRecords);
        if (targetStockRecord == null) {
            return false;
        }

        if (stockCreateTime != null && (targetStockRecord.getCreateTime() == null
                || !stockCreateTime.equals(targetStockRecord.getCreateTime()))) {
            targetStockRecord.setCreateTime(stockCreateTime);
            stockInRecordService.updateById(targetStockRecord);
        }

        approveStockRecords(Collections.singletonList(targetStockRecord));
        stockRecords = findDirectStockRecords(purchaseLedger.getId(), purchaseLedger.getPurchaseContractNumber(), product.getProductModelId(), product.getId());
        return hasApprovedStockRecord(stockRecords);
    }

    private LocalDateTime toStartOfDayPlusDays(Date date, int days) {
        if (date == null) {
            return null;
        }
        return DateUtils.toLocalDate(date).plusDays(days).atStartOfDay();
    }

    private LocalDateTime resolveQualityStockCreateTime(QualityInspect qualityInspect) {
        if (qualityInspect == null || qualityInspect.getCheckTime() == null) {
            return null;
        }
        return DateUtils.toLocalDate(qualityInspect.getCheckTime()).plusDays(1).atStartOfDay();
    }

    private QualityInspect findLatestPurchaseQualityInspect(Long purchaseLedgerId, Long productModelId) {
        if (purchaseLedgerId == null || productModelId == null) {
            return null;
        }
        return qualityInspectMapper.selectOne(
                Wrappers.<QualityInspect>lambdaQuery()
                        .eq(QualityInspect::getInspectType, 0)
                        .eq(QualityInspect::getPurchaseLedgerId, purchaseLedgerId)
                        .eq(QualityInspect::getProductModelId, productModelId)
                        .orderByDesc(QualityInspect::getId)
                        .last("limit 1")
        );
    }

    private List<StockInRecord> findQualityStockRecords(Long qualityInspectId, Long productModelId) {
        if (qualityInspectId == null || productModelId == null) {
            return Collections.emptyList();
        }
        return stockInRecordService.list(
                Wrappers.<StockInRecord>lambdaQuery()
                        .eq(StockInRecord::getRecordType, StockInQualifiedRecordTypeEnum.CUSTOMIZATION_UNSTOCK_OUT.getCode())
                        .eq(StockInRecord::getRecordId, qualityInspectId)
                        .eq(StockInRecord::getProductModelId, productModelId)
                        .orderByDesc(StockInRecord::getId)
        );
    }

    private List<StockInRecord> findDirectStockRecords(Long purchaseLedgerId, String purchaseContractNumber, Long productModelId, Long purchaseProductId) {
        if (purchaseLedgerId == null || productModelId == null || purchaseProductId == null || !StringUtils.hasText(purchaseContractNumber)) {
            return Collections.emptyList();
        }
        String batchNo = purchaseContractNumber + "-" + purchaseProductId;
        return stockInRecordService.list(
                Wrappers.<StockInRecord>lambdaQuery()
                        .eq(StockInRecord::getRecordType, StockInQualifiedRecordTypeEnum.PURCHASE_STOCK_IN.getCode())
                        .eq(StockInRecord::getRecordId, purchaseLedgerId)
                        .eq(StockInRecord::getProductModelId, productModelId)
                        .eq(StockInRecord::getBatchNo, batchNo)
                        .orderByDesc(StockInRecord::getId)
        );
    }

    private boolean hasApprovedStockRecord(List<StockInRecord> stockRecords) {
        return stockRecords != null && stockRecords.stream()
                .anyMatch(item -> ReviewStatusEnum.APPROVED.getCode().equals(item.getApprovalStatus()));
    }

    private StockInRecord findLatestUnapprovedStockRecord(List<StockInRecord> stockRecords) {
        if (CollectionUtils.isEmpty(stockRecords)) {
            return null;
        }
        return stockRecords.stream()
                .filter(item -> !ReviewStatusEnum.APPROVED.getCode().equals(item.getApprovalStatus()))
                .findFirst()
                .orElse(null);
    }

    private void approveStockRecords(List<StockInRecord> stockRecords) {
        if (CollectionUtils.isEmpty(stockRecords)) {
            return;
        }
        List<Long> rejectedIds = stockRecords.stream()
                .filter(item -> ReviewStatusEnum.REJECTED.getCode().equals(item.getApprovalStatus()))
                .map(StockInRecord::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        if (!rejectedIds.isEmpty()) {
            stockInRecordService.batchReAudit(rejectedIds);
        }

        List<Long> pendingIds = stockRecords.stream()
                .filter(item -> item.getApprovalStatus() == null
                        || ReviewStatusEnum.PENDING_REVIEW.getCode().equals(item.getApprovalStatus())
                        || ReviewStatusEnum.REJECTED.getCode().equals(item.getApprovalStatus()))
                .map(StockInRecord::getId)
                .filter(Objects::nonNull)
                .collect(Collectors.toList());
        if (!pendingIds.isEmpty()) {
            stockInRecordService.batchApprove(pendingIds, ReviewStatusEnum.APPROVED.getCode());
        }
    }

@@ -617,14 +1027,28 @@
        if (loginUser == null) {
            return;
        }
        ApproveProcessVO approveProcessVO = new ApproveProcessVO();
        approveProcessVO.setApproveType(5);
        approveProcessVO.setApproveDeptId(loginUser.getCurrentDeptId());
        approveProcessVO.setApproveReason(purchaseLedger.getPurchaseContractNumber());
        approveProcessVO.setApproveUserIds(purchaseLedger.getApproveUserIds());
        approveProcessVO.setApproveUser(loginUser.getUserId());
        approveProcessVO.setApproveTime(LocalDate.now().toString());
        approveProcessService.addApprove(approveProcessVO);
        ApprovalTemplate approvalTemplate = approvalTemplateMapper.selectOne(
                new LambdaQueryWrapper<ApprovalTemplate>()
                        .eq(ApprovalTemplate::getBusinessType, 5L)
                        .orderByDesc(ApprovalTemplate::getId)
                        .last("LIMIT 1")
        );
        if (approvalTemplate == null) {
            throw new BaseException("请先配置采购审批模板");
        }

        ApprovalInstanceDto approvalInstance = new ApprovalInstanceDto();
        approvalInstance.setTemplateId(approvalTemplate.getId());
        approvalInstance.setTemplateName(approvalTemplate.getTemplateName());
        approvalInstance.setBusinessId(purchaseLedger.getId());
        approvalInstance.setBusinessType(5L);
        approvalInstance.setCurrentLevel(1);
        approvalInstance.setApplicantId(loginUser.getUserId());
        approvalInstance.setTitle(purchaseLedger.getPurchaseContractNumber()+"审批");
        approvalInstance.setApplicantName(loginUser.getNickName());
        approvalInstance.setApplyTime(LocalDateTime.now());
        approvalInstanceService.add(approvalInstance);

    }

    /**