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

buhuazhen

2 天以前 fdb632b25e13186c2af67e53e019acecaf363ac0

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

@@ -50,10 +50,12 @@
import com.ruoyi.sales.pojo.InvoiceRegistrationProduct;
import com.ruoyi.sales.pojo.SalesLedger;
import com.ruoyi.sales.pojo.SalesLedgerProduct;
import com.ruoyi.sales.service.impl.CommonFileServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
@@ -83,51 +85,71 @@
 * @date 2025-05-09
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class PurchaseLedgerServiceImpl extends ServiceImpl<PurchaseLedgerMapper, PurchaseLedger> implements IPurchaseLedgerService {
    private final AccountExpenseService accountExpenseService;
    private final PurchaseLedgerMapper purchaseLedgerMapper;
    @Autowired
    private  AccountExpenseService accountExpenseService;
    @Autowired
    private  PurchaseLedgerMapper purchaseLedgerMapper;

    private final SalesLedgerMapper salesLedgerMapper;
    private final SalesLedgerProductMapper salesLedgerProductMapper;
    @Autowired
    private  SalesLedgerMapper salesLedgerMapper;
    @Autowired
    private  SalesLedgerProductMapper salesLedgerProductMapper;

    private final SysUserMapper userMapper;
    @Autowired
    private  SysUserMapper userMapper;

    private final TempFileMapper tempFileMapper;
    @Autowired
    private  TempFileMapper tempFileMapper;

    private final CommonFileMapper commonFileMapper;
    @Autowired
    private  CommonFileMapper commonFileMapper;

    private final SupplierManageMapper supplierManageMapper;
    @Autowired
    private  SupplierManageMapper supplierManageMapper;

    private final ProductMapper productMapper;
    @Autowired
    private  ProductMapper productMapper;

    private final ProductModelMapper productModelMapper;
    @Autowired
    private  ProductModelMapper productModelMapper;

    private final SysUserMapper sysUserMapper;
    @Autowired
    private  SysUserMapper sysUserMapper;

    private final TicketRegistrationMapper ticketRegistrationMapper;
    @Autowired
    private  TicketRegistrationMapper ticketRegistrationMapper;

    private final ProductRecordMapper productRecordMapper;
    @Autowired
    private  ProductRecordMapper productRecordMapper;

    private final PaymentRegistrationMapper paymentRegistrationMapper;

    private final InvoiceRegistrationProductMapper invoiceRegistrationProductMapper;

    private final StringRedisTemplate redisTemplate;
    private final QualityInspectMapper qualityInspectMapper;
    private final QualityTestStandardBindingMapper qualityTestStandardBindingMapper;
    private final QualityTestStandardParamMapper qualityTestStandardParamMapper;
    private final QualityTestStandardMapper qualityTestStandardMapper;
    private final QualityInspectParamMapper qualityInspectParamMapper;

    private final ApproveProcessServiceImpl approveProcessService;

    private final ProcurementRecordMapper procurementRecordStorageMapper;

    private final PurchaseLedgerTemplateMapper purchaseLedgerTemplateMapper;

    private final SalesLedgerProductTemplateMapper salesLedgerProductTemplateMapper;
    @Autowired
    private  PaymentRegistrationMapper paymentRegistrationMapper;
    @Autowired
    private  InvoiceRegistrationProductMapper invoiceRegistrationProductMapper;
    @Autowired
    private  StringRedisTemplate redisTemplate;
    @Autowired
    private  QualityInspectMapper qualityInspectMapper;
    @Autowired
    private  CommonFileServiceImpl commonFileService;
    @Autowired
    private  QualityTestStandardBindingMapper qualityTestStandardBindingMapper;
    @Autowired
    private  QualityTestStandardParamMapper qualityTestStandardParamMapper;
    @Autowired
    private  QualityTestStandardMapper qualityTestStandardMapper;
    @Autowired
    private  QualityInspectParamMapper qualityInspectParamMapper;
    @Autowired
    private  ApproveProcessServiceImpl approveProcessService;
    @Autowired
    private  ProcurementRecordMapper procurementRecordStorageMapper;
    @Autowired
    private  PurchaseLedgerTemplateMapper purchaseLedgerTemplateMapper;
    @Autowired
    private  SalesLedgerProductTemplateMapper salesLedgerProductTemplateMapper;
    @Value("${file.upload-dir}")
    private String uploadDir;

@@ -136,6 +158,12 @@
        LambdaQueryWrapper<PurchaseLedger> queryWrapper = new LambdaQueryWrapper<>();
        if (StringUtils.isNotBlank(purchaseLedger.getPurchaseContractNumber())) {
            queryWrapper.like(PurchaseLedger::getPurchaseContractNumber, purchaseLedger.getPurchaseContractNumber());
        }
        if(purchaseLedger.getSupplierId()!=null){
            queryWrapper.eq(PurchaseLedger::getSupplierId, purchaseLedger.getSupplierId());
        }
        if (purchaseLedger.getApprovalStatus() != null) {
            queryWrapper.eq(PurchaseLedger::getApprovalStatus, purchaseLedger.getApprovalStatus());
        }
        return purchaseLedgerMapper.selectList(queryWrapper);
    }
@@ -187,15 +215,15 @@
        if (productList != null && !productList.isEmpty()) {
            handleSalesLedgerProducts(purchaseLedger.getId(), productList, purchaseLedgerDto.getType());
        }
        //新增原材料检验
        if (productList != null) {
            for (SalesLedgerProduct saleProduct : productList) {
                //是否推送质检，如果true就添加
                if (saleProduct.getIsChecked()) {
                    addQualityInspect(purchaseLedger, saleProduct);
                }
            }
        }
        //新增原材料检验  审批之后才生成检验
//        if (productList != null) {
//            for (SalesLedgerProduct saleProduct : productList) {
//                //是否推送质检，如果true就添加
//                if (saleProduct.getIsChecked()) {
//                    addQualityInspect(purchaseLedger, saleProduct);
//                }
//            }
//        }
        // 5. 迁移临时文件到正式目录
        if (purchaseLedgerDto.getTempFileIds() != null && !purchaseLedgerDto.getTempFileIds().isEmpty()) {
            migrateTempFilesToFormal(purchaseLedger.getId(), purchaseLedgerDto.getTempFileIds());
@@ -203,7 +231,8 @@
        return 1;
    }

    private void addQualityInspect(PurchaseLedger purchaseLedger, SalesLedgerProduct saleProduct) {

    public void addQualityInspect(PurchaseLedger purchaseLedger, SalesLedgerProduct saleProduct) {
        QualityInspect qualityInspect = new QualityInspect();
        qualityInspect.setInspectType(0);
        qualityInspect.setSupplier(purchaseLedger.getSupplierName());
@@ -398,6 +427,12 @@
        if (ids == null || ids.length == 0) {
           throw new BaseException("请选中至少一条数据");
        }
        for (Long id : ids) {
            PurchaseLedger purchaseLedger = purchaseLedgerMapper.selectById(id);
            if (purchaseLedger.getApprovalStatus().equals(3)) {
                throw new BaseException(purchaseLedger.getPurchaseContractNumber()+"已经审批通过，不允许删除");
            }
        }
        // 批量删除关联的采购入库记录
        LambdaQueryWrapper<SalesLedgerProduct> salesLedgerProductQueryWrapper = new LambdaQueryWrapper<>();
        salesLedgerProductQueryWrapper.in(SalesLedgerProduct::getSalesLedgerId, ids)
@@ -431,6 +466,7 @@
        //批量删除检验标准
        LambdaQueryWrapper<QualityInspect> materialInspectLambdaQueryWrapper = new LambdaQueryWrapper<>();
        materialInspectLambdaQueryWrapper.in(QualityInspect::getPurchaseLedgerId, ids);

        List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(materialInspectLambdaQueryWrapper);
        qualityInspects.stream().forEach(qualityInspect -> {
            if (ObjectUtils.isNotEmpty(qualityInspect.getInspectState())&&qualityInspect.getInspectState().equals(1)) {
@@ -462,6 +498,8 @@
        }
        //批量删除原材料检验数据
        qualityInspectMapper.delete(materialInspectLambdaQueryWrapper);
        //删除附件
        commonFileService.deleteByBusinessIds(Arrays.asList(ids), 2);
        // 批量删除采购台账
        return purchaseLedgerMapper.deleteBatchIds(Arrays.asList(ids));
    }
@@ -631,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())));
@@ -638,6 +712,23 @@
            // 录入人数据
            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,
                    salesLedgerImportDtoList.stream().map(PurchaseLedgerImportDto::getRecorderName).collect(Collectors.toList())));
            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);
@@ -656,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) {
@@ -716,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