产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
liyong
10 天以前 2d03ec79e1892248b520cf097e8a58dd82a4892f 
 src/main/java/com/ruoyi/purchase/service/impl/PurchaseLedgerServiceImpl.java


@@ -1,5 +1,6 @@


package com.ruoyi.purchase.service.impl;




import cn.hutool.core.util.StrUtil;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;


import com.baomidou.mybatisplus.core.metadata.IPage;


@@ -7,23 +8,19 @@


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.account.pojo.AccountExpense;


import com.ruoyi.account.pojo.AccountIncome;


import com.ruoyi.account.service.AccountExpenseService;


import com.ruoyi.account.service.AccountIncomeService;


import com.ruoyi.approve.bean.vo.ApproveProcessVO;


import com.ruoyi.approve.pojo.ApproveProcess;


import com.ruoyi.approve.service.impl.ApproveProcessServiceImpl;


import com.ruoyi.approve.vo.ApproveProcessVO;


import com.ruoyi.basic.dto.ProductModelAnticlockwiseDto;


import com.ruoyi.basic.mapper.ProductMapper;


import com.ruoyi.basic.mapper.ProductModelMapper;


import com.ruoyi.basic.mapper.SupplierManageMapper;


import com.ruoyi.basic.pojo.Customer;


import com.ruoyi.basic.pojo.Product;


import com.ruoyi.basic.pojo.ProductModel;


import com.ruoyi.basic.pojo.SupplierManage;


import com.ruoyi.common.enums.FileNameType;


import com.ruoyi.common.exception.base.BaseException;


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;


@@ -39,21 +36,29 @@


import com.ruoyi.purchase.dto.PurchaseLedgerImportDto;


import com.ruoyi.purchase.dto.PurchaseLedgerProductImportDto;


import com.ruoyi.purchase.mapper.*;


import com.ruoyi.purchase.pojo.*;


import com.ruoyi.purchase.pojo.PaymentRegistration;


import com.ruoyi.purchase.pojo.ProductRecord;


import com.ruoyi.purchase.pojo.PurchaseLedger;


import com.ruoyi.purchase.pojo.TicketRegistration;


import com.ruoyi.purchase.service.IPurchaseLedgerService;


import com.ruoyi.quality.mapper.*;


import com.ruoyi.quality.pojo.*;


import com.ruoyi.sales.dto.SalesLedgerImportDto;


import com.ruoyi.sales.dto.SalesLedgerProductImportDto;


import com.ruoyi.sales.mapper.*;


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.InvoiceRegistrationProductMapper;


import com.ruoyi.sales.mapper.SalesLedgerMapper;


import com.ruoyi.sales.mapper.SalesLedgerProductMapper;


import com.ruoyi.sales.pojo.CommonFile;


import com.ruoyi.sales.pojo.InvoiceRegistrationProduct;


import com.ruoyi.sales.pojo.SalesLedger;


import com.ruoyi.sales.pojo.SalesLedgerProduct;


import lombok.RequiredArgsConstructor;


import com.ruoyi.sales.service.impl.CommonFileServiceImpl;


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 +88,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;




@@ -143,16 +168,25 @@


    @Override


    @Transactional(rollbackFor = Exception.class)


    public int addOrEditPurchase(PurchaseLedgerDto purchaseLedgerDto) throws Exception {




        PurchaseLedger purchaseLedger = new PurchaseLedger();


        SalesLedger salesLedger = salesLedgerMapper.selectById(purchaseLedgerDto.getSalesLedgerId());


        BeanUtils.copyProperties(purchaseLedgerDto, purchaseLedger);


        //录入人


        SysUser sysUser = userMapper.selectUserById(purchaseLedgerDto.getRecorderId());


        if (ObjectUtils.isNotEmpty(sysUser)) {


            purchaseLedger.setRecorderName(sysUser.getNickName());


            purchaseLedger.setPhoneNumber(sysUser.getPhonenumber());


        }else {


            purchaseLedger.setRecorderName(SecurityUtils.getLoginUser().getNickName());


            SysUser sysUser1 = userMapper.selectUserById(SecurityUtils.getUserId());


            purchaseLedger.setPhoneNumber(sysUser1.getPhonenumber());


        }




        SupplierManage supplierManage = supplierManageMapper.selectById(purchaseLedgerDto.getSupplierId());




        // DTO转Entity


        PurchaseLedger purchaseLedger = new PurchaseLedger();


        BeanUtils.copyProperties(purchaseLedgerDto, purchaseLedger);






        LoginUser loginUser = SecurityUtils.getLoginUser();


        if (ObjectUtils.isNotEmpty(loginUser) && null != loginUser.getTenantId()) {


            purchaseLedger.setTenantId(loginUser.getTenantId());


@@ -161,8 +195,7 @@


        purchaseLedger.setSalesLedgerId(ObjectUtils.isNotEmpty(salesLedger) ? salesLedger.getId() : -1);


        purchaseLedger.setSupplierName(supplierManage.getSupplierName());


        purchaseLedger.setRecorderId(purchaseLedgerDto.getRecorderId());


        purchaseLedger.setRecorderName(sysUser.getNickName());


        purchaseLedger.setPhoneNumber(sysUser.getPhonenumber());




        purchaseLedger.setApprovalStatus(1);


        // 3. 新增或更新主表


        if (purchaseLedger.getId() == null) {


@@ -187,15 +220,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 +236,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 +432,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 +471,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 +503,8 @@


        }


        //批量删除原材料检验数据


        qualityInspectMapper.delete(materialInspectLambdaQueryWrapper);


        //删除附件


        commonFileService.deleteByBusinessIds(Arrays.asList(ids), 2);


        // 批量删除采购台账


        return purchaseLedgerMapper.deleteBatchIds(Arrays.asList(ids));


    }


@@ -621,108 +664,175 @@


    @Transactional(rollbackFor = Exception.class)


    public AjaxResult importData(MultipartFile file) {


        LoginUser loginUser = SecurityUtils.getLoginUser();


        int successCount = 0;


        int skipCount = 0;


        List<String> errorMessages = new ArrayList<>();




        try {


            InputStream inputStream = file.getInputStream();


            ExcelUtil<PurchaseLedgerImportDto> salesLedgerImportDtoExcelUtil = new ExcelUtil<>(PurchaseLedgerImportDto.class);


            Map<String, List<PurchaseLedgerImportDto>> stringListMap = salesLedgerImportDtoExcelUtil.importExcelMultiSheet(Arrays.asList("采购台账数据", "采购产品数据"), inputStream, 0);


            ExcelUtil<PurchaseLedgerImportDto> excelUtil = new ExcelUtil<>(PurchaseLedgerImportDto.class);


            Map<String, List<PurchaseLedgerImportDto>> stringListMap = excelUtil.importExcelMultiSheet(Arrays.asList("采购台账数据", "采购产品数据"), inputStream, 0);


            if (CollectionUtils.isEmpty(stringListMap)) return AjaxResult.error("采购表格为空！");


            // 业务层合并


            List<PurchaseLedgerImportDto> salesLedgerImportDtoList = stringListMap.get("采购台账数据");


            if (CollectionUtils.isEmpty(salesLedgerImportDtoList)) return AjaxResult.error("采购台账数据为空！");


            List<PurchaseLedgerImportDto> salesLedgerProductImportDtoList = stringListMap.get("采购产品数据");


            if (CollectionUtils.isEmpty(salesLedgerProductImportDtoList)) return AjaxResult.error("采购产品数据为空！");


            // 供应商数据


            List<SupplierManage> customers = supplierManageMapper.selectList(new LambdaQueryWrapper<SupplierManage>().in(SupplierManage::getSupplierName,


                    salesLedgerImportDtoList.stream().map(PurchaseLedgerImportDto::getSupplierName).collect(Collectors.toList())));


            List<Map<String,Object>> list = productModelMapper.getProductAndModelList();


            // 录入人数据


            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,


                    salesLedgerImportDtoList.stream().map(PurchaseLedgerImportDto::getRecorderName).collect(Collectors.toList())));


            for (PurchaseLedgerImportDto salesLedgerImportDto : salesLedgerImportDtoList) {


                PurchaseLedger salesLedger = new PurchaseLedger();


                BeanUtils.copyProperties(salesLedgerImportDto, salesLedger);


                // 通过供应商名称查询ID


                salesLedger.setSupplierId(customers.stream()


                        .filter(customer -> customer.getSupplierName().equals(salesLedger.getSupplierName()))


                        .findFirst()


                        .map(SupplierManage::getId)


                        .orElse(null));


                Long aLong = sysUsers.stream()


                        .filter(sysUser -> sysUser.getNickName().equals(salesLedger.getRecorderName()))


                        .findFirst()


                        .map(SysUser::getUserId)


                        .orElse(null);


                if (aLong == null)


                    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() + ",无对应产品数据！");


                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])


                            .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) {


                    SalesLedgerProduct salesLedgerProduct = new SalesLedgerProduct();


                    BeanUtils.copyProperties(salesLedgerProductImportDto, salesLedgerProduct);


                    salesLedgerProduct.setSalesLedgerId(salesLedger.getId());


                    salesLedgerProduct.setType(2);


                    // 计算不含税总价


                    salesLedgerProduct.setTaxExclusiveTotalPrice(salesLedgerProduct.getTaxInclusiveTotalPrice().divide(new BigDecimal(1).add(salesLedgerProduct.getTaxRate().divide(new BigDecimal(100))), 2, RoundingMode.HALF_UP));


                    salesLedgerProduct.setFutureTickets(salesLedgerProduct.getQuantity());


                    salesLedgerProduct.setFutureTicketsAmount(salesLedgerProduct.getTaxExclusiveTotalPrice());


                    list.stream()


                            .filter(map -> map.get("productName").equals(salesLedgerProduct.getProductCategory()) && map.get("model").equals(salesLedgerProduct.getSpecificationModel()))


                            .findFirst()


                            .ifPresent(map -> {


                                salesLedgerProduct.setProductModelId(Long.parseLong(map.get("modelId").toString()));


                                salesLedgerProduct.setProductId(Long.parseLong(map.get("id").toString()));


                            });


                    salesLedgerProduct.setRegister(loginUser.getNickName());


                    salesLedgerProduct.setRegisterDate(LocalDateTime.now());


                    salesLedgerProduct.setApproveStatus(0);


                    salesLedgerProduct.setPendingTicketsTotal(salesLedgerProductImportDto.getTaxInclusiveTotalPrice());


                    // 是否质检判断


                    salesLedgerProduct.setIsChecked(salesLedgerProductImportDto.getIsChecked() == 1);


                    if(salesLedgerProductImportDto.getIsChecked() == 1){


                        addQualityInspect(salesLedger, salesLedgerProduct);


                    }


                    salesLedgerProductMapper.insert(salesLedgerProduct);


            List<PurchaseLedgerImportDto> ledgerList = stringListMap.get("采购台账数据");


            if (CollectionUtils.isEmpty(ledgerList)) return AjaxResult.error("采购台账数据为空！");


            List<PurchaseLedgerImportDto> productList = stringListMap.get("采购产品数据");


            if (CollectionUtils.isEmpty(productList)) return AjaxResult.error("采购产品数据为空！");




            List<SupplierManage> suppliers = supplierManageMapper.selectList(new LambdaQueryWrapper<SupplierManage>().in(SupplierManage::getSupplierName,


                    ledgerList.stream().map(PurchaseLedgerImportDto::getSupplierName).filter(StrUtil::isNotBlank).collect(Collectors.toList())));


            List<SysUser> sysUsers = sysUserMapper.selectList(new LambdaQueryWrapper<SysUser>().in(SysUser::getNickName,


                    ledgerList.stream().map(PurchaseLedgerImportDto::getRecorderName).filter(StrUtil::isNotBlank).collect(Collectors.toList())));




            for (int i = 0; i < ledgerList.size(); i++) {


                PurchaseLedgerImportDto importDto = ledgerList.get(i);


                int rowNum = i + 2;




                if (StrUtil.isBlank(importDto.getPurchaseContractNumber())) {


                    errorMessages.add(String.format("第%d行：采购单号为空", rowNum));


                    skipCount++;


                    continue;


                }


                // 采购审核


                addApproveByPurchase(loginUser,salesLedger);




                try {


                    PurchaseLedger existLedger = purchaseLedgerMapper.selectOne(new LambdaQueryWrapper<PurchaseLedger>()


                            .eq(PurchaseLedger::getPurchaseContractNumber, importDto.getPurchaseContractNumber())


                            .last("limit 1"));


                    if (existLedger != null) {


                        errorMessages.add(String.format("第%d行：采购单号[%s]已存在", rowNum, importDto.getPurchaseContractNumber()));


                        skipCount++;


                        continue;


                    }




                    PurchaseLedger purchaseLedger = new PurchaseLedger();


                    BeanUtils.copyProperties(importDto, purchaseLedger);




                    purchaseLedger.setSupplierId(suppliers.stream()


                            .filter(s -> s.getSupplierName().equals(importDto.getSupplierName()))


                            .findFirst()


                            .map(SupplierManage::getId)


                            .orElse(null));




                    Long recorderId = sysUsers.stream()


                            .filter(u -> u.getNickName().equals(importDto.getRecorderName()))


                            .findFirst()


                            .map(SysUser::getUserId)


                            .orElse(null);


                    if (recorderId == null) {


                        throw new RuntimeException("录入人:" + importDto.getRecorderName() + "不存在");


                    }


                    purchaseLedger.setRecorderId(recorderId);




                    List<PurchaseLedgerProductImportDto> productDtos = productList.stream()


                            .filter(p -> p.getPurchaseContractNumber().equals(importDto.getPurchaseContractNumber()))


                            .collect(Collectors.toList());


                    if (CollectionUtils.isEmpty(productDtos)) {


                        throw new RuntimeException("无对应产品数据");


                    }




                    purchaseLedger.setContractAmount(productDtos.stream()


                            .map(PurchaseLedgerProductImportDto::getTaxInclusiveTotalPrice)


                            .reduce(BigDecimal.ZERO, BigDecimal::add));




                    SalesLedger salesLedger = salesLedgerMapper.selectOne(new LambdaQueryWrapper<SalesLedger>()


                            .eq(SalesLedger::getSalesContractNo, purchaseLedger.getSalesContractNo())


                            .last("LIMIT 1"));


                    if (salesLedger != null) {


                        purchaseLedger.setSalesLedgerId(salesLedger.getId());


                    }




                    purchaseLedgerMapper.insert(purchaseLedger);




                    for (PurchaseLedgerProductImportDto productDto : productDtos) {


                        SalesLedgerProduct product = new SalesLedgerProduct();


                        BeanUtils.copyProperties(productDto, product);


                        product.setSalesLedgerId(purchaseLedger.getId());


                        product.setType(2);


                        product.setTaxExclusiveTotalPrice(product.getTaxInclusiveTotalPrice()


                                .divide(new BigDecimal(1).add(product.getTaxRate().divide(new BigDecimal(100))), 2, RoundingMode.HALF_UP));


                        product.setFutureTickets(product.getQuantity());


                        product.setFutureTicketsAmount(product.getTaxExclusiveTotalPrice());




                        ProductModelAnticlockwiseDto modelDto = new ProductModelAnticlockwiseDto();


                        modelDto.setProductName(product.getProductCategory());


                        modelDto.setModel(product.getSpecificationModel());


                        modelDto.setUnit(product.getUnit());


                        modelDto.setSubUnit(product.getUnit());


                        product.setProductModelId(productModelAnticlockwise(modelDto));




                        product.setRegister(loginUser.getNickName());


                        product.setRegisterDate(LocalDateTime.now());


                        product.setApproveStatus(0);


                        product.setPendingTicketsTotal(productDto.getTaxInclusiveTotalPrice());


                        product.setIsChecked(productDto.getIsChecked() == 1);




                        if (productDto.getIsChecked() == 1) {


                            addQualityInspect(purchaseLedger, product);


                        }


                        salesLedgerProductMapper.insert(product);


                    }




                    addApproveByPurchase(loginUser, purchaseLedger);


                    successCount++;




                } catch (Exception e) {


                    log.error("第{}行采购单[{}]导入失败：{}", rowNum, importDto.getPurchaseContractNumber(), e.getMessage(), e);


                    errorMessages.add(String.format("第%d行采购单[%s]：失败-%s", rowNum, importDto.getPurchaseContractNumber(), e.getMessage()));


                    skipCount++;


                }


            }




            return AjaxResult.success("导入成功");


            String message = String.format("导入完成！成功%d条，跳过%d条", successCount, skipCount);


            if (!errorMessages.isEmpty()) {


                message += "。错误详情：" + String.join("；", errorMessages);


            }


            return AjaxResult.success(message);


        } catch (Exception e) {


            e.printStackTrace();


            log.error("采购导入异常", e);


            return AjaxResult.error("导入失败：" + e.getMessage());


        }


        return AjaxResult.success("导入失败");


    }




    public Long productModelAnticlockwise(ProductModelAnticlockwiseDto productModelDto) {


        ProductModel oldProductModel = productModelMapper.selectOldProductModel(productModelDto.getModel(), productModelDto.getProductName());


        //存在就更新


        if (oldProductModel != null) {


            oldProductModel.setModel(productModelDto.getModel());


            oldProductModel.setUnit(productModelDto.getUnit());


            oldProductModel.setSubUnit(productModelDto.getSubUnit());


            oldProductModel.setDeptId(SecurityUtils.getDeptId()[0]);


            productModelMapper.updateById(oldProductModel);


            Product product = productMapper.selectById(oldProductModel.getProductId());


            product.setProductName(productModelDto.getProductName());


            productMapper.updateById(product);


            return oldProductModel.getId();


        }else {


            //找到父节点


            Product productParent = productMapper.selectOne(new QueryWrapper<Product>().lambda().eq(Product::getProductName, "原料").last("limit 1"));


            if (ObjectUtils.isEmpty(productParent)) {


                Product product = new Product();


                product.setProductName("原料");


                product.setDeptId(SecurityUtils.getDeptId()[0]);


                productMapper.insert(product);


                productParent.setId(product.getId());


            }


            //新增产品大类


            Product product = new Product();


            product.setProductName(productModelDto.getProductName());


            product.setParentId(productParent.getId());


            product.setDeptId(SecurityUtils.getDeptId()[0]);


            productMapper.insert( product);


            //新增产品规格


            ProductModel productModel = new ProductModel();


            productModel.setProductId(product.getId());


            productModel.setModel(productModelDto.getModel());


            productModel.setUnit(productModelDto.getUnit());


            productModel.setSubUnit(productModelDto.getSubUnit());


            productModel.setDeptId(SecurityUtils.getDeptId()[0]);


            productModelMapper.insert(productModel);


            return productModel.getId();




        }


    }




    @Override