feat: 采购合同号重复问题调整

buhuazhen

2 天以前 fdb632b25e13186c2af67e53e019acecaf363ac0

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

@@ -669,6 +669,42 @@
            if (CollectionUtils.isEmpty(salesLedgerImportDtoList)) return AjaxResult.error("采购台账数据为空！");
            List<PurchaseLedgerImportDto> salesLedgerProductImportDtoList = stringListMap.get("采购产品数据");
            if (CollectionUtils.isEmpty(salesLedgerProductImportDtoList)) return AjaxResult.error("采购产品数据为空！");

            // 为采购合同号为空的数据自动生成采购合同号
            for (PurchaseLedgerImportDto dto : salesLedgerImportDtoList) {
                if (StringUtils.isBlank(dto.getPurchaseContractNumber())) {
                    dto.setPurchaseContractNumber(getPurchaseNo());
                }
            }

            // 检查Excel中是否有重复的采购单号（排除空值）
            Map<String, Long> purchaseNoCountMap = salesLedgerImportDtoList.stream()
                    .filter(dto -> StringUtils.isNotBlank(dto.getPurchaseContractNumber()))
                    .collect(Collectors.groupingBy(PurchaseLedgerImportDto::getPurchaseContractNumber, Collectors.counting()));
            List<String> duplicateInExcel = purchaseNoCountMap.entrySet().stream()
                    .filter(entry -> entry.getValue() > 1)
                    .map(Map.Entry::getKey)
                    .collect(Collectors.toList());
            if (!duplicateInExcel.isEmpty()) {
                return AjaxResult.error("Excel中存在重复的采购单号：" + String.join("、", duplicateInExcel));
            }

            // 检查数据库中已存在的采购单号
            List<String> purchaseNos = salesLedgerImportDtoList.stream()
                    .filter(dto -> StringUtils.isNotBlank(dto.getPurchaseContractNumber()))
                    .map(PurchaseLedgerImportDto::getPurchaseContractNumber)
                    .collect(Collectors.toList());
            if (!purchaseNos.isEmpty()) {
                List<PurchaseLedger> existingLedgers = purchaseLedgerMapper.selectList(new LambdaQueryWrapper<PurchaseLedger>()
                        .in(PurchaseLedger::getPurchaseContractNumber, purchaseNos));
                List<String> existingPurchaseNos = existingLedgers.stream()
                        .map(PurchaseLedger::getPurchaseContractNumber)
                        .collect(Collectors.toList());
                if (!existingPurchaseNos.isEmpty()) {
                    return AjaxResult.error("以下采购单号已存在：" + String.join("、", existingPurchaseNos));
                }
            }

            // 供应商数据
            List<SupplierManage> customers = supplierManageMapper.selectList(new LambdaQueryWrapper<SupplierManage>().in(SupplierManage::getSupplierName,
                    salesLedgerImportDtoList.stream().map(PurchaseLedgerImportDto::getSupplierName).collect(Collectors.toList())));
@@ -676,13 +712,24 @@
            // 录入人数据
            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,
                    salesLedgerImportDtoList.stream().map(PurchaseLedgerImportDto::getRecorderName).collect(Collectors.toList())));
            for (PurchaseLedgerImportDto salesLedgerImportDto : salesLedgerImportDtoList) {
                PurchaseLedger purchaseLedger = purchaseLedgerMapper.selectOne(new LambdaQueryWrapper<PurchaseLedger>()
                        .eq(PurchaseLedger::getPurchaseContractNumber, salesLedgerImportDto.getPurchaseContractNumber())
                        .last("limit 1"));
                if(purchaseLedger != null){
            int successCount = 0;

            // 建立采购单号与产品数据的映射关系（包括自动生成的采购单号）
            Map<String, List<PurchaseLedgerProductImportDto>> productMap = new HashMap<>();
            for (PurchaseLedgerImportDto ledgerDto : salesLedgerImportDtoList) {
                String purchaseContractNumber = ledgerDto.getPurchaseContractNumber();
                // 如果采购单号为空，产品数据通过其他方式匹配（如行号）
                if (StringUtils.isBlank(purchaseContractNumber)) {
                    continue;
                }
                List<PurchaseLedgerProductImportDto> products = salesLedgerProductImportDtoList.stream()
                        .filter(productDto -> productDto.getPurchaseContractNumber() != null &&
                                productDto.getPurchaseContractNumber().equals(purchaseContractNumber))
                        .collect(Collectors.toList());
                productMap.put(purchaseContractNumber, products);
            }

            for (PurchaseLedgerImportDto salesLedgerImportDto : salesLedgerImportDtoList) {
                PurchaseLedger salesLedger = new PurchaseLedger();
                BeanUtils.copyProperties(salesLedgerImportDto, salesLedger);
                // 通过供应商名称查询ID
@@ -700,35 +747,42 @@
                    throw new RuntimeException("录入人:" + salesLedger.getRecorderName() + ",无对应用户！");
                salesLedger.setRecorderId(aLong);
                // 采购产品数据绑定，通过采购单号获取对应采购产品数据
                List<PurchaseLedgerProductImportDto> salesLedgerProductImportDtos = salesLedgerProductImportDtoList.stream()
                        .filter(salesLedgerProductImportDto -> salesLedgerProductImportDto.getPurchaseContractNumber().equals(salesLedger.getPurchaseContractNumber()))
                        .collect(Collectors.toList());
                if (CollectionUtils.isEmpty(salesLedgerProductImportDtos))
                    throw new RuntimeException("采购单号:" + salesLedgerImportDto.getPurchaseContractNumber() + ",无对应产品数据！");
                String purchaseContractNumber = salesLedgerImportDto.getPurchaseContractNumber();
                List<PurchaseLedgerProductImportDto> salesLedgerProductImportDtos = productMap.get(purchaseContractNumber);
                if (CollectionUtils.isEmpty(salesLedgerProductImportDtos)) {
                    // 如果产品数据中的采购单号为空，按顺序匹配（适用于导入时产品数据采购单号也为空的情况）
                    salesLedgerProductImportDtos = salesLedgerProductImportDtoList.stream()
                            .filter(dto -> StringUtils.isBlank(dto.getPurchaseContractNumber()))
                            .collect(Collectors.toList());
                }
                salesLedger.setContractAmount(salesLedgerProductImportDtos.stream()
                        .map(PurchaseLedgerProductImportDto::getTaxInclusiveTotalPrice)
                        .reduce(BigDecimal.ZERO,BigDecimal::add));
                // 通过销售单号绑定销售
                SalesLedger salesLedger1 = salesLedgerMapper.selectOne(new LambdaQueryWrapper<SalesLedger>()
                        .eq(SalesLedger::getSalesContractNo, salesLedger.getSalesContractNo())
                        .last("LIMIT 1"));
                if(salesLedger1 != null){
                    salesLedger.setSalesLedgerId(salesLedger1.getId());
                }
                // 采购审核
                // 通过昵称获取用户ID
                String[] split = salesLedger.getApproveUserIds().split("，");
                List<Long> ids = new ArrayList<>();
                for (int i = 0; i < split.length; i++) {
                    SysUser sysUser = sysUserMapper.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getNickName, split[i])
                if (StringUtils.isNotBlank(salesLedger.getSalesContractNo())) {
                    SalesLedger salesLedger1 = salesLedgerMapper.selectOne(new LambdaQueryWrapper<SalesLedger>()
                            .eq(SalesLedger::getSalesContractNo, salesLedger.getSalesContractNo())
                            .last("LIMIT 1"));
                    if (sysUser != null) {
                        ids.add(sysUser.getUserId());
                    if(salesLedger1 != null){
                        salesLedger.setSalesLedgerId(salesLedger1.getId());
                    }
                }
                // 将集合转为字符串，隔开
                String collect = ids.stream().map(Object::toString).collect(Collectors.joining(","));
                salesLedger.setApproveUserIds(collect);
                // 采购审核
                if (StringUtils.isNotBlank(salesLedger.getApproveUserIds())) {
                    // 通过昵称获取用户ID
                    String[] split = salesLedger.getApproveUserIds().split("，");
                    List<Long> ids = new ArrayList<>();
                    for (int i = 0; i < split.length; i++) {
                        SysUser sysUser = sysUserMapper.selectOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getNickName, split[i])
                                .last("LIMIT 1"));
                        if (sysUser != null) {
                            ids.add(sysUser.getUserId());
                        }
                    }
                    // 将集合转为字符串，隔开
                    String collect = ids.stream().map(Object::toString).collect(Collectors.joining(","));
                    salesLedger.setApproveUserIds(collect);
                }
                purchaseLedgerMapper.insert(salesLedger);

                for (PurchaseLedgerProductImportDto salesLedgerProductImportDto : salesLedgerProductImportDtos) {
@@ -760,13 +814,14 @@
                }
                // 采购审核
                addApproveByPurchase(loginUser,salesLedger);
                successCount++;
            }

            return AjaxResult.success("导入成功");
            return AjaxResult.success("导入成功，共导入" + successCount + "条数据");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return AjaxResult.success("导入失败");
        return AjaxResult.error("导入失败");
    }

    @Override