fix:发货分批发货

liding

2026-04-15 3e28d83281050fb1f06b786a4a0c4839ba643a06

 src/main/java/com/ruoyi/sales/service/impl/SalesLedgerProductServiceImpl.java

@@ -5,16 +5,17 @@
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.enums.StockQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockUnQualifiedRecordTypeEnum;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.ProductModel;
import com.ruoyi.common.enums.StockInUnQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.production.dto.ProductStructureDto;
import com.ruoyi.production.mapper.*;
import com.ruoyi.production.pojo.*;
import com.ruoyi.production.service.impl.ProductOrderServiceImpl;
import com.ruoyi.purchase.mapper.PurchaseLedgerMapper;
import com.ruoyi.purchase.pojo.PurchaseLedger;
import com.ruoyi.quality.mapper.QualityInspectMapper;
@@ -25,7 +26,6 @@
import com.ruoyi.sales.mapper.SalesLedgerMapper;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
import com.ruoyi.sales.mapper.ShippingInfoMapper;
import com.ruoyi.sales.pojo.InvoiceRegistrationProduct;
import com.ruoyi.sales.pojo.SalesLedger;
import com.ruoyi.sales.pojo.SalesLedgerProduct;
import com.ruoyi.sales.pojo.ShippingInfo;
@@ -44,7 +44,10 @@
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

@@ -85,6 +88,7 @@
    private ShippingInfoServiceImpl shippingInfoService;

    private StockUtils stockUtils;
    private ProductModelMapper productModelMapper;



@@ -92,6 +96,8 @@
    private ProductStructureMapper productStructureMapper;
    @Autowired
    private StockInventoryMapper stockInventoryMapper;
    @Autowired
    private ProductOrderServiceImpl productOrderServiceImpl;

    @Override
    public SalesLedgerProduct selectSalesLedgerProductById(Long id) {
@@ -106,6 +112,9 @@
        List<SalesLedgerProduct> salesLedgerProducts = salesLedgerProductMapper.selectSalesLedgerProductList(salesLedgerProduct);
        if(!CollectionUtils.isEmpty(salesLedgerProducts)){
            salesLedgerProducts.forEach(item -> {
                ProductModel productModel = productModelMapper.selectById(item.getProductModelId());
                item.setUidNo(productModel != null ? productModel.getUidNo() : "");

                // 发货信息
                ShippingInfo shippingInfo = shippingInfoMapper.selectOne(new LambdaQueryWrapper<ShippingInfo>()
                        .eq(ShippingInfo::getSalesLedgerProductId, item.getId())
@@ -228,9 +237,7 @@
            /*删除对应的生产数据并重新新增*/
            deleteProductionData(Arrays.asList(salesLedgerProduct.getId()));
            // 删除生产核算数据
            LambdaQueryWrapper<SalesLedgerProductionAccounting> reportWrapper = new LambdaQueryWrapper<>();
            reportWrapper.in(SalesLedgerProductionAccounting::getSalesLedgerId, salesLedgerId);
            salesLedgerProductionAccountingMapper.delete(reportWrapper);

            addProductionData(salesLedgerProduct);
        }

@@ -272,7 +279,8 @@
        productOrder.setSalesLedgerId(salesLedgerProduct.getSalesLedgerId());
        productOrder.setProductModelId(salesLedgerProduct.getProductModelId());
        productOrder.setSaleLedgerProductId(salesLedgerProduct.getId());
        productOrder.setNpsNo("SC" + String.format("%08d", salesLedgerProduct.getId()));
        String string = productOrderServiceImpl.generateNextOrderNo(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd")));
        productOrder.setNpsNo(string);
        productOrder.setQuantity(salesLedgerProduct.getQuantity());//需求数量
        productOrder.setCompleteQuantity(BigDecimal.ZERO);//完成数量
        productOrderMapper.insert(productOrder);
@@ -280,7 +288,7 @@
        List<ProcessRoute> processRoutes = processRouteMapper.selectList(new QueryWrapper<ProcessRoute>().lambda()
                .eq(ProcessRoute::getProductModelId, salesLedgerProduct.getProductModelId())
                .orderByDesc(ProcessRoute::getCreateTime));
        if (processRoutes.size()>0){
        if (!processRoutes.isEmpty()){
            ProcessRoute processRoute = processRoutes.get(0);
            //新增生产订单工艺路线主表
            ProductProcessRoute productProcessRoute = new ProductProcessRoute();
@@ -303,13 +311,7 @@
                int insert = productProcessRouteItemMapper.insert(productProcessRouteItem);
                if (insert > 0) {
                    // 查询今日已存在的最大工单号
                    QueryWrapper<ProductWorkOrder> queryWrapper = new QueryWrapper<>();
                    queryWrapper.likeRight("work_order_no", datePrefix)
                            .orderByDesc("work_order_no")
                            .last("LIMIT 1");

                    ProductWorkOrder lastWorkOrder = productWorkOrderMapper.selectOne(queryWrapper);

                    ProductWorkOrder lastWorkOrder = productWorkOrderMapper.selectMax(datePrefix);
                    int sequenceNumber = 1; // 默认序号
                    if (lastWorkOrder != null && lastWorkOrder.getWorkOrderNo() != null) {
                        String lastNo = lastWorkOrder.getWorkOrderNo().toString();
@@ -323,7 +325,7 @@
                        }
                    }
                    // 生成完整的工单号
                    String workOrderNoStr = String.format("%s%03d", datePrefix, sequenceNumber);
                    String workOrderNoStr ="GD"+ String.format("%s%03d", datePrefix, sequenceNumber);
                    ProductWorkOrder productWorkOrder = new ProductWorkOrder();
                    productWorkOrder.setProductProcessRouteItemId(productProcessRouteItem.getId());
                    productWorkOrder.setProductOrderId(productOrder.getId());
@@ -345,89 +347,93 @@
     */
    public void deleteProductionData(List<Long> productIds) {
        //批量查询productOrder
        List<ProductOrder> productOrders = productOrderMapper.selectList(
                new LambdaQueryWrapper<ProductOrder>()
                        .in(ProductOrder::getSaleLedgerProductId, productIds)
        );
        if (!org.springframework.util.CollectionUtils.isEmpty(productOrders)) {
            List<Long> orderIds = productOrders.stream()
                    .map(ProductOrder::getId)
                    .collect(Collectors.toList());

            // 批量查询processRouteItems
            List<ProductProcessRouteItem> allRouteItems = productProcessRouteItemMapper.selectList(
                    new LambdaQueryWrapper<ProductProcessRouteItem>()
                            .in(ProductProcessRouteItem::getProductOrderId, orderIds)
        if (productIds != null && !productIds.isEmpty()) {
            List<ProductOrder> productOrders = productOrderMapper.selectList(
                    new LambdaQueryWrapper<ProductOrder>()
                            .in(ProductOrder::getSaleLedgerProductId, productIds)
            );

            if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(allRouteItems)) {
                // 获取要删除的工序项ID
                List<Long> routeItemIds = allRouteItems.stream()
                        .map(ProductProcessRouteItem::getId)
            if (!org.springframework.util.CollectionUtils.isEmpty(productOrders)) {
                List<Long> orderIds = productOrders.stream()
                        .map(ProductOrder::getId)
                        .collect(Collectors.toList());

                // 查询关联的工单ID
                List<ProductWorkOrder> workOrders = productWorkOrderMapper.selectList(
                        new LambdaQueryWrapper<ProductWorkOrder>()
                                .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds)
                // 批量查询processRouteItems
                List<ProductProcessRouteItem> allRouteItems = productProcessRouteItemMapper.selectList(
                        new LambdaQueryWrapper<ProductProcessRouteItem>()
                                .in(ProductProcessRouteItem::getProductOrderId, orderIds)
                );
                if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(workOrders)) {
                    List<Long> workOrderIds = workOrders.stream()
                            .map(ProductWorkOrder::getId)

                if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(allRouteItems)) {
                    // 获取要删除的工序项ID
                    List<Long> routeItemIds = allRouteItems.stream()
                            .map(ProductProcessRouteItem::getId)
                            .collect(Collectors.toList());

                    // 查询关联的生产主表ID
                    List<ProductionProductMain> productMains = productionProductMainMapper.selectList(
                            new LambdaQueryWrapper<ProductionProductMain>()
                                    .in(ProductionProductMain::getWorkOrderId, workOrderIds)
                    // 查询关联的工单ID
                    List<ProductWorkOrder> workOrders = productWorkOrderMapper.selectList(
                            new LambdaQueryWrapper<ProductWorkOrder>()
                                    .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds)
                    );
                    List<Long> productMainIds = productMains.stream()
                            .map(ProductionProductMain::getId)
                            .collect(Collectors.toList());
                    if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(workOrders)) {
                        List<Long> workOrderIds = workOrders.stream()
                                .map(ProductWorkOrder::getId)
                                .collect(Collectors.toList());

                    // 删除产出表、投入表数据
                    if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(productMainIds)) {
                        productionProductOutputMapper.deleteByProductMainIds(productMainIds);
                        productionProductInputMapper.deleteByProductMainIds(productMainIds);
                        List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
                                new LambdaQueryWrapper<QualityInspect>()
                                        .in(QualityInspect::getProductMainId, productMainIds)
                        // 查询关联的生产主表ID
                        List<ProductionProductMain> productMains = productionProductMainMapper.selectList(
                                new LambdaQueryWrapper<ProductionProductMain>()
                                        .in(ProductionProductMain::getWorkOrderId, workOrderIds)
                        );
                        //删除出库记录
                        for (Long productMainId : productMainIds) {
                            //删除生产出库记录
                            stockUtils.deleteStockOutRecord(productMainId, StockQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode());
                            //删除报废的入库记录
                            stockUtils.deleteStockInRecord(productMainId, StockUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode());
                        }
                        qualityInspects.forEach(qualityInspect -> {
                            //inspectState=1 已提交 不能删除
                            if (qualityInspect.getInspectState() == 1) {
                                throw new RuntimeException("已提交的检验单不能删除");
                        List<Long> productMainIds = productMains.stream()
                                .map(ProductionProductMain::getId)
                                .collect(Collectors.toList());

                        // 删除产出表、投入表数据
                        if (!com.baomidou.mybatisplus.core.toolkit.CollectionUtils.isEmpty(productMainIds)) {
                            productionProductOutputMapper.deleteByProductMainIds(productMainIds);
                            productionProductInputMapper.deleteByProductMainIds(productMainIds);
                            List<QualityInspect> qualityInspects = qualityInspectMapper.selectList(
                                    new LambdaQueryWrapper<QualityInspect>()
                                            .in(QualityInspect::getProductMainId, productMainIds)
                            );
                            //删除出库记录
                            for (Long productMainId : productMainIds) {
                                //删除生产出库记录
                                stockUtils.deleteStockOutRecord(productMainId, StockOutQualifiedRecordTypeEnum.PRODUCTION_REPORT_STOCK_OUT.getCode());
                                //删除报废的入库记录
                                stockUtils.deleteStockInRecord(productMainId, StockInUnQualifiedRecordTypeEnum.PRODUCTION_SCRAP.getCode());
                            }
                        });
                        qualityInspectMapper.deleteByProductMainIds(productMainIds);
                            qualityInspects.forEach(qualityInspect -> {
                                //inspectState=1 已提交 不能删除
                                if (qualityInspect.getInspectState() == 1) {
                                    throw new RuntimeException("已提交的检验单不能删除");
                                }
                            });
                            qualityInspectMapper.deleteByProductMainIds(productMainIds);
                            salesLedgerProductionAccountingMapper.delete(new LambdaQueryWrapper<SalesLedgerProductionAccounting>()
                                    .in(SalesLedgerProductionAccounting::getProductMainId, productMainIds));
                        }

                        // 删除生产主表数据
                        productionProductMainMapper.deleteByWorkOrderIds(workOrderIds);

                        // 删除工单数据
                        productWorkOrderMapper.delete(new LambdaQueryWrapper<ProductWorkOrder>()
                                .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds));
                    }

                    // 删除生产主表数据
                    productionProductMainMapper.deleteByWorkOrderIds(workOrderIds);

                    // 删除工单数据
                    productWorkOrderMapper.delete(new LambdaQueryWrapper<ProductWorkOrder>()
                            .in(ProductWorkOrder::getProductProcessRouteItemId, routeItemIds));
                }
                // 批量删除processRouteItem
                productProcessRouteItemMapper.delete(new LambdaQueryWrapper<ProductProcessRouteItem>()
                        .in(ProductProcessRouteItem::getProductOrderId, orderIds));

                // 批量删除productProcessRoute
                productProcessRouteMapper.delete(new LambdaQueryWrapper<ProductProcessRoute>()
                        .in(ProductProcessRoute::getProductOrderId, orderIds));

                // 批量删除productOrder
                productOrderMapper.delete(new LambdaQueryWrapper<ProductOrder>()
                        .in(ProductOrder::getSaleLedgerProductId, productIds));
            }
            // 批量删除processRouteItem
            productProcessRouteItemMapper.delete(new LambdaQueryWrapper<ProductProcessRouteItem>()
                    .in(ProductProcessRouteItem::getProductOrderId, orderIds));

            // 批量删除productProcessRoute
            productProcessRouteMapper.delete(new LambdaQueryWrapper<ProductProcessRoute>()
                    .in(ProductProcessRoute::getProductOrderId, orderIds));

            // 批量删除productOrder
            productOrderMapper.delete(new LambdaQueryWrapper<ProductOrder>()
                    .in(ProductOrder::getSaleLedgerProductId, productIds));
        }
    }

@@ -450,7 +456,7 @@
        IPage<SalesLedgerProductDto> salesLedgerProductDtoIPage = salesLedgerProductMapper.listPagePurchaseLedger(page, salesLedgerProduct);
        salesLedgerProductDtoIPage.getRecords().forEach(item -> {
            // 判断状态
            if(item.getTaxInclusiveTotalPrice().compareTo(item.getInvoiceTotal()) == 0){
            if(item.getTaxInclusiveTotalPrice().compareTo(item.getTicketsTotal()) == 0){
                item.setStatusName("已完成付款");
            }else{
                item.setStatusName("未完成付款");