feat: 销售台账增加一个宽高搜索，页面加面积、数量的字段展示

gongchunyi

8 小时以前 93b93bacbe43fcd2f13884ec02782baf77193d35

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

@@ -19,6 +19,9 @@
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.enums.SaleEnum;
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockInUnQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockOutQualifiedRecordTypeEnum;
import com.ruoyi.common.enums.StockOutUnQualifiedRecordTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.DateUtils;
@@ -37,6 +40,7 @@
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysDeptMapper;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.procurementrecord.utils.StockUtils;
import com.ruoyi.purchase.dto.SimpleReturnOrderGroupDto;
import com.ruoyi.purchase.mapper.PurchaseReturnOrderProductsMapper;
import com.ruoyi.quality.mapper.QualityInspectMapper;
@@ -139,6 +143,7 @@
    private final StockOutRecordMapper stockOutRecordMapper;
    private final StockInRecordService stockInRecordService;
    private final StockOutRecordService stockOutRecordService;
    private final StockUtils stockUtils;

    @Autowired
    private SysDeptMapper sysDeptMapper;
@@ -272,6 +277,7 @@
                    product.setActualTotalArea(pieceArea.multiply(quantity).setScale(2, RoundingMode.HALF_UP));
                }
            }
            product.fillRemainingQuantity();
        }

        // 3.查询上传文件
@@ -412,7 +418,112 @@

    @Override
    public IPage<SalesLedger> selectSalesLedgerListPage(Page page, SalesLedgerDto salesLedgerDto) {
        return salesLedgerMapper.selectSalesLedgerListPage(page, salesLedgerDto);
        IPage<SalesLedger> iPage = salesLedgerMapper.selectSalesLedgerListPage(page, salesLedgerDto);

        if (CollectionUtils.isEmpty(iPage.getRecords())) {
            return iPage;
        }

        List<Long> salesLedgerIds = iPage.getRecords().stream().map(SalesLedger::getId).collect(Collectors.toList());

        boolean hasWidthHeightFilter = salesLedgerDto.getWidth() != null || salesLedgerDto.getHeight() != null;
        Map<Long, List<SalesLedgerProduct>> matchedProductsMap = Collections.emptyMap();
        if (hasWidthHeightFilter) {
            LambdaQueryWrapper<SalesLedgerProduct> productQueryWrapper = new LambdaQueryWrapper<SalesLedgerProduct>()
                    .in(SalesLedgerProduct::getSalesLedgerId, salesLedgerIds)
                    .eq(SalesLedgerProduct::getType, 1);
            if (salesLedgerDto.getWidth() != null) {
                productQueryWrapper.eq(SalesLedgerProduct::getWidth, salesLedgerDto.getWidth());
            }
            if (salesLedgerDto.getHeight() != null) {
                productQueryWrapper.eq(SalesLedgerProduct::getHeight, salesLedgerDto.getHeight());
            }
            List<SalesLedgerProduct> matchedProducts = salesLedgerProductMapper.selectList(productQueryWrapper);
            matchedProductsMap = CollectionUtils.isEmpty(matchedProducts) ? Collections.emptyMap()
                    : matchedProducts.stream().collect(Collectors.groupingBy(SalesLedgerProduct::getSalesLedgerId));
        }

        List<SalesLedgerProductTotalsDto> productTotals = salesLedgerProductMapper.selectSalesLedgerProductTotals(salesLedgerIds, 1);
        Map<Long, SalesLedgerProductTotalsDto> productTotalsMap = CollectionUtils.isEmpty(productTotals)
                ? Collections.emptyMap()
                : productTotals.stream()
                .filter(t -> t.getSalesLedgerId() != null)
                .collect(Collectors.toMap(SalesLedgerProductTotalsDto::getSalesLedgerId, Function.identity(), (a, b) -> a));

        List<InvoiceLedgerDto> invoiceLedgerDtoList = invoiceLedgerMapper.invoicedTotal(salesLedgerIds);
        if (CollectionUtils.isEmpty(invoiceLedgerDtoList)) {
            invoiceLedgerDtoList = Collections.emptyList();
        }

        Map<Long, BigDecimal> invoiceTotals = invoiceLedgerDtoList.stream()
                .filter(dto -> dto.getSalesLedgerId() != null && dto.getInvoiceTotal() != null)
                .collect(Collectors.toMap(
                        dto -> dto.getSalesLedgerId().longValue(),
                        InvoiceLedgerDto::getInvoiceTotal,
                        BigDecimal::add
                ));

        List<ReceiptPayment> receiptPayments = Collections.emptyList();
        if (!CollectionUtils.isEmpty(salesLedgerIds)) {
            receiptPayments = receiptPaymentMapper.selectList(new LambdaQueryWrapper<ReceiptPayment>()
                    .in(ReceiptPayment::getSalesLedgerId, salesLedgerIds));
        }

        Map<Long, BigDecimal> receiptTotals = new HashMap<>();
        if (!CollectionUtils.isEmpty(receiptPayments)) {
            for (ReceiptPayment receiptPayment : receiptPayments) {
                if (receiptPayment.getSalesLedgerId() != null && receiptPayment.getReceiptPaymentAmount() != null) {
                    receiptTotals.merge(receiptPayment.getSalesLedgerId(), receiptPayment.getReceiptPaymentAmount(), BigDecimal::add);
                }
            }
        }

        for (SalesLedger salesLedger : iPage.getRecords()) {
            Long ledgerId = salesLedger.getId();

            SalesLedgerProductTotalsDto totals = productTotalsMap.get(ledgerId);
            if (totals != null) {
                salesLedger.setProductTotalQuantity(totals.getTotalQuantity() != null ? totals.getTotalQuantity() : BigDecimal.ZERO);
                salesLedger.setProductTotalArea(totals.getTotalArea() != null ? totals.getTotalArea() : BigDecimal.ZERO);
            } else {
                salesLedger.setProductTotalQuantity(BigDecimal.ZERO);
                salesLedger.setProductTotalArea(BigDecimal.ZERO);
            }
            if (hasWidthHeightFilter) {
                salesLedger.setMatchedProducts(matchedProductsMap.getOrDefault(ledgerId, Collections.emptyList()));
            }

            BigDecimal contractAmount = salesLedger.getContractAmount() == null ? BigDecimal.ZERO : salesLedger.getContractAmount();
            BigDecimal invoiceTotal = invoiceTotals.getOrDefault(ledgerId, BigDecimal.ZERO);
            BigDecimal receiptPaymentAmountTotal = receiptTotals.getOrDefault(ledgerId, BigDecimal.ZERO);

            BigDecimal noInvoiceAmountTotal = contractAmount.subtract(invoiceTotal);
            if (noInvoiceAmountTotal.compareTo(BigDecimal.ZERO) < 0) {
                noInvoiceAmountTotal = BigDecimal.ZERO;
            }

            BigDecimal noReceiptPaymentAmountTotal = invoiceTotal.subtract(receiptPaymentAmountTotal);
            if (noReceiptPaymentAmountTotal.compareTo(BigDecimal.ZERO) < 0) {
                noReceiptPaymentAmountTotal = BigDecimal.ZERO;
            }

            salesLedger.setNoInvoiceAmountTotal(noInvoiceAmountTotal);
            salesLedger.setInvoiceTotal(invoiceTotal);
            salesLedger.setReceiptPaymentAmountTotal(receiptPaymentAmountTotal);
            salesLedger.setNoReceiptAmount(noReceiptPaymentAmountTotal);

            boolean hasInvoiceOperation = invoiceTotal.compareTo(BigDecimal.ZERO) > 0;
            boolean hasReceiptOperation = receiptPaymentAmountTotal.compareTo(BigDecimal.ZERO) > 0;
            salesLedger.setIsEdit(!(hasInvoiceOperation || hasReceiptOperation));
        }

        if (salesLedgerDto.getStatus() != null && salesLedgerDto.getStatus()) {
            iPage.getRecords().removeIf(salesLedger ->
                    Objects.equals(salesLedger.getNoInvoiceAmountTotal(), new BigDecimal("0.00")));
            iPage.setTotal(iPage.getRecords().size());
        }

        return iPage;
    }

    @Override
@@ -620,6 +731,7 @@
                salesLedgerProduct.setNoInvoiceNum(quantity);
                salesLedgerProduct.setNoInvoiceAmount(salesLedgerProduct.getTaxExclusiveTotalPrice());
                salesLedgerProduct.setPendingInvoiceTotal(taxInclusiveTotalPrice);
                salesLedgerProduct.fillRemainingQuantity();
                salesLedgerProductMapper.insert(salesLedgerProduct);
                if (!processList.isEmpty()) {
                    salesLedgerProductProcessBindService.updateProductProcessBind(processList, salesLedgerProduct.getId());
@@ -999,7 +1111,16 @@
        if (!updateList.isEmpty()) {
            for (SalesLedgerProduct product : updateList) {
                product.setType(type.getCode());
                product.setProductStockStatus(0);
                SalesLedgerProduct db = salesLedgerProductMapper.selectById(product.getId());
                if (db != null) {
                    BigDecimal stockedQty = product.getStockedQuantity() != null ? product.getStockedQuantity() : db.getStockedQuantity();
                    BigDecimal orderQty = product.getQuantity() != null ? product.getQuantity() : db.getQuantity();
                    product.setStockedQuantity(stockedQty);
                    product.setProductStockStatus(calculateProductStockStatus(stockedQty, orderQty));
                } else {
                    product.setProductStockStatus(0);
                }
                product.fillRemainingQuantity();
                salesLedgerProductMapper.updateById(product);
                //  清空销售产品绑定的加工
                salesLedgerProductProcessBindService.updateProductProcessBind(product.getSalesProductProcessList(), product.getId());
@@ -1012,7 +1133,10 @@
                salesLedgerProduct.setNoInvoiceNum(salesLedgerProduct.getQuantity());
                salesLedgerProduct.setNoInvoiceAmount(salesLedgerProduct.getTaxInclusiveTotalPrice());
                salesLedgerProduct.setPendingInvoiceTotal(salesLedgerProduct.getTaxInclusiveTotalPrice());
                salesLedgerProduct.setProductStockStatus(0);
                BigDecimal stockedQty = salesLedgerProduct.getStockedQuantity();
                BigDecimal orderQty = salesLedgerProduct.getQuantity();
                salesLedgerProduct.setProductStockStatus(calculateProductStockStatus(stockedQty, orderQty));
                salesLedgerProduct.fillRemainingQuantity();
                salesLedgerProductMapper.insert(salesLedgerProduct);
                //  绑定产品额外加工
                //  清空销售产品绑定的加工
@@ -1021,6 +1145,41 @@
//                salesLedgerProductServiceImpl.addProductionData(salesLedgerProduct);
            }
        }
        refreshSalesLedgerStockStatus(salesLedgerId);
    }

    private int calculateProductStockStatus(BigDecimal stockedQty, BigDecimal orderQty) {
        BigDecimal stocked = stockedQty == null ? BigDecimal.ZERO : stockedQty;
        BigDecimal order = orderQty == null ? BigDecimal.ZERO : orderQty;
        if (stocked.compareTo(BigDecimal.ZERO) <= 0) {
            return 0;
        }
        if (order.compareTo(BigDecimal.ZERO) > 0 && stocked.compareTo(order) < 0) {
            return 1;
        }
        return 2;
    }

    private void refreshSalesLedgerStockStatus(Long salesLedgerId) {
        if (salesLedgerId == null) return;
        SalesLedger ledger = baseMapper.selectById(salesLedgerId);
        if (ledger == null) return;
        List<SalesLedgerProduct> allProducts = salesLedgerProductMapper.selectList(
                Wrappers.<SalesLedgerProduct>lambdaQuery()
                        .eq(SalesLedgerProduct::getSalesLedgerId, salesLedgerId)
                        .eq(SalesLedgerProduct::getType, SaleEnum.SALE.getCode()));
        if (CollectionUtils.isEmpty(allProducts)) {
            ledger.setStockStatus(0);
            baseMapper.updateById(ledger);
            return;
        }
        boolean anyInbound = allProducts.stream().anyMatch(p -> {
            BigDecimal sq = p.getStockedQuantity();
            return sq != null && sq.compareTo(BigDecimal.ZERO) > 0;
        });
        boolean allFull = allProducts.stream().allMatch(p -> Objects.equals(p.getProductStockStatus(), 2));
        ledger.setStockStatus(allFull ? 2 : (anyInbound ? 1 : 0));
        baseMapper.updateById(ledger);
    }

    private SalesLedger convertToEntity(SalesLedgerDto dto) {
@@ -1183,13 +1342,19 @@
        List<SalesProcessCardDto.ProcessNodeDto> nodeDtos = new ArrayList<>();

        if (CollectionUtils.isEmpty(salesLedgerProcessRoutes)) {
            // 无自定义路线，取默认路线
            ProcessRoute defaultRoute = processRouteMapper.selectOne(
            // 无自定义路线：先查询默认工艺路线；若无默认，获取创建时间最近的一条
            ProcessRoute fallbackRoute = processRouteMapper.selectOne(
                    new LambdaQueryWrapper<ProcessRoute>().eq(ProcessRoute::getIsDefault, 1).last("LIMIT 1"));
            if (defaultRoute != null) {
            if (fallbackRoute == null) {
                fallbackRoute = processRouteMapper.selectOne(
                        new LambdaQueryWrapper<ProcessRoute>()
                                .orderByDesc(ProcessRoute::getCreateTime)
                                .last("LIMIT 1"));
            }
            if (fallbackRoute != null) {
                List<ProcessRouteItem> routeItems = processRouteItemMapper.selectList(
                        new LambdaQueryWrapper<ProcessRouteItem>()
                                .eq(ProcessRouteItem::getRouteId, defaultRoute.getId())
                                .eq(ProcessRouteItem::getRouteId, fallbackRoute.getId())
                                .orderByAsc(ProcessRouteItem::getDragSort));
                for (ProcessRouteItem i : routeItems) {
                    SalesProcessCardDto.ProcessNodeDto node = new SalesProcessCardDto.ProcessNodeDto();
@@ -1438,58 +1603,88 @@

        //  查询所有产品
        List<SalesLedgerProduct> allProducts = salesLedgerProductMapper.selectList(
                new LambdaQueryWrapper<SalesLedgerProduct>().in(SalesLedgerProduct::getSalesLedgerId, salesLedgerIds));
                new LambdaQueryWrapper<SalesLedgerProduct>()
                        .in(SalesLedgerProduct::getSalesLedgerId, salesLedgerIds)
                        .eq(SalesLedgerProduct::getType, 1));

        if (CollectionUtils.isNotEmpty(allProducts)) {
            Map<Long, SalesLedger> ledgerMap = ledgers.stream()
                    .collect(Collectors.toMap(SalesLedger::getId, Function.identity()));

            Map<Long, List<SalesLedgerProduct>> groupedData = new LinkedHashMap<>();
            for (SalesLedgerProduct p : allProducts) {
                groupedData.computeIfAbsent(p.getSalesLedgerId(), k -> new ArrayList<>()).add(p);
            }

            List<SalesInvoicesDto.InvoiceOrderGroupDto> groups = new ArrayList<>();
            BigDecimal totalQty = BigDecimal.ZERO;
            BigDecimal totalArea = BigDecimal.ZERO;

            for (Map.Entry<Long, List<SalesLedgerProduct>> ledgerEntry : groupedData.entrySet()) {
                SalesLedger ledger = ledgerMap.get(ledgerEntry.getKey());
                String orderNo = ledger != null ? ledger.getSalesContractNo() : "";
                List<SalesLedgerProduct> products = ledgerEntry.getValue();
            Map<String, List<SalesLedgerProduct>> groupedData = new LinkedHashMap<>();
            Map<String, Set<String>> groupOrderNos = new LinkedHashMap<>();
            for (SalesLedgerProduct p : allProducts) {
                String productCategory = StringUtils.defaultString(p.getProductCategory(), "");
                String specificationModel = StringUtils.defaultString(p.getSpecificationModel(), "");
                String groupKey = productCategory + "||" + specificationModel;
                groupedData.computeIfAbsent(groupKey, k -> new ArrayList<>()).add(p);

                SalesLedger ledger = ledgerMap.get(p.getSalesLedgerId());
                String orderNo = ledger != null ? StringUtils.defaultString(ledger.getSalesContractNo(), "") : "";
                if (StringUtils.isNotEmpty(orderNo)) {
                    groupOrderNos.computeIfAbsent(groupKey, k -> new LinkedHashSet<>()).add(orderNo);
                }
            }

            for (Map.Entry<String, List<SalesLedgerProduct>> productEntry : groupedData.entrySet()) {
                String key = productEntry.getKey();
                String[] parts = key.split("\\|\\|", -1);
                String productName = parts.length > 0 ? parts[0] : "";
                String specificationModel = parts.length > 1 ? parts[1] : "";
                List<SalesLedgerProduct> products = productEntry.getValue();

                SalesInvoicesDto.InvoiceOrderGroupDto group = new SalesInvoicesDto.InvoiceOrderGroupDto();
                group.setSalesContractNo(orderNo);
                if (CollectionUtils.isNotEmpty(products)) {
                    group.setProductName(products.get(0).getProductCategory());
                }
                Set<String> orderNos = groupOrderNos.getOrDefault(key, Collections.emptySet());
                group.setSalesContractNo(String.join(",", orderNos));
                group.setProductName(productName);
                group.setSpecificationModel(specificationModel);

                List<SalesInvoicesDto.InvoiceItemDto> itemDtos = new ArrayList<>();
                Map<String, SalesInvoicesDto.InvoiceItemDto> mergedItems = new LinkedHashMap<>();
                BigDecimal groupQty = BigDecimal.ZERO;
                BigDecimal groupArea = BigDecimal.ZERO;

                for (SalesLedgerProduct p : products) {
                    SalesInvoicesDto.InvoiceItemDto item = new SalesInvoicesDto.InvoiceItemDto();
                    item.setFloorCode(p.getFloorCode());
                    item.setWidthHeight((p.getWidth() != null ? p.getWidth().stripTrailingZeros().toPlainString() : "0") +
                            " * " + (p.getHeight() != null ? p.getHeight().stripTrailingZeros().toPlainString() : "0"));
                    item.setQuantity(p.getQuantity());
                    String widthHeight = (p.getWidth() != null ? p.getWidth().stripTrailingZeros().toPlainString() : "0") +
                            " * " + (p.getHeight() != null ? p.getHeight().stripTrailingZeros().toPlainString() : "0");
                    String floorCode = StringUtils.defaultString(p.getFloorCode(), "");
                    String remark = StringUtils.defaultString(p.getRemark(), "");
                    String processReq = StringUtils.defaultString(p.getProcessRequirement(), "");
                    String itemKey = floorCode + "||" + widthHeight + "||" + remark + "||" + processReq;

                    BigDecimal qty = p.getQuantity() != null ? p.getQuantity() : BigDecimal.ZERO;

                    // 面积
                    BigDecimal area = p.getSettleTotalArea() != null ? p.getSettleTotalArea() : p.getActualTotalArea();
                    if (area == null && p.getWidth() != null && p.getHeight() != null && p.getQuantity() != null) {
                        area = p.getWidth().multiply(p.getHeight()).multiply(p.getQuantity()).divide(new BigDecimal(1000000), 2, RoundingMode.HALF_UP);
                    }
                    item.setArea(area);
                    item.setRemark(p.getRemark());
                    item.setProcessRequirement(p.getProcessRequirement());
                    area = area != null ? area : BigDecimal.ZERO;

                    itemDtos.add(item);
                    groupQty = groupQty.add(p.getQuantity() != null ? p.getQuantity() : BigDecimal.ZERO);
                    groupArea = groupArea.add(area != null ? area : BigDecimal.ZERO);
                    SalesInvoicesDto.InvoiceItemDto item = mergedItems.get(itemKey);
                    if (item == null) {
                        item = new SalesInvoicesDto.InvoiceItemDto();
                        item.setFloorCode(floorCode);
                        item.setWidthHeight(widthHeight);
                        item.setSpecificationModel(p.getSpecificationModel());
                        item.setQuantity(qty);
                        item.setArea(area);
                        item.setRemark(remark);
                        item.setProcessRequirement(processReq);
                        mergedItems.put(itemKey, item);
                    } else {
                        item.setQuantity((item.getQuantity() != null ? item.getQuantity() : BigDecimal.ZERO).add(qty));
                        item.setArea((item.getArea() != null ? item.getArea() : BigDecimal.ZERO).add(area));
                    }

                    groupQty = groupQty.add(qty);
                    groupArea = groupArea.add(area);
                }

                group.setItems(itemDtos);
                group.setItems(new ArrayList<>(mergedItems.values()));
                group.setGroupTotalQuantity(groupQty);
                group.setGroupTotalArea(groupArea.setScale(2, RoundingMode.HALF_UP));
                groups.add(group);
@@ -1550,7 +1745,7 @@
                SalesLabelDto dto = new SalesLabelDto();
                dto.setCustomerName(salesLedger.getCustomerName());
                dto.setSalesContractNo(salesLedger.getSalesContractNo());
                dto.setProductName(p.getProductCategory());
                dto.setProductName(p.getSpecificationModel());

                // 宽*高=数量
                String specification = (p.getWidth() != null ? p.getWidth().stripTrailingZeros().toPlainString() : "0") + "*" +
@@ -1675,22 +1870,55 @@
            throw new ServiceException("入库失败,未查询到该销售订单的销售产品");
        }
        for (SalesLedgerProduct product : salesLedgerProducts) {
            if (!Objects.equals(product.getSalesLedgerId(), ledger.getId())) {
                throw new ServiceException("入库失败,存在不属于当前销售订单的产品");
            }
            if (product.getProductModelId() == null) {
                continue;
            }
            BigDecimal orderQty = product.getQuantity() == null ? BigDecimal.ZERO : product.getQuantity();
            BigDecimal oldStocked = product.getStockedQuantity() == null ? BigDecimal.ZERO : product.getStockedQuantity();
            BigDecimal inboundQty = orderQty.subtract(oldStocked);
            if (inboundQty.compareTo(BigDecimal.ZERO) < 0) {
                inboundQty = BigDecimal.ZERO;
            }
            if (inboundQty.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }
            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setRecordId(product.getId());
            stockInventoryDto.setRecordType(StockInQualifiedRecordTypeEnum.SALE_STOCK_IN.getCode());
            stockInventoryDto.setQualitity(product.getQuantity());
            stockInventoryDto.setQualitity(inboundQty);
            stockInventoryDto.setProductModelId(product.getProductModelId());
            stockInventoryDto.setSalesLedgerId(ledger.getId());
            stockInventoryDto.setSalesLedgerProductId(product.getId());
            stockInventoryService.addstockInventory(stockInventoryDto);

            BigDecimal newStocked = oldStocked.add(inboundQty);
            int lineStockStatus;
            if (newStocked.compareTo(BigDecimal.ZERO) <= 0) {
                lineStockStatus = 0;
            } else if (orderQty.compareTo(BigDecimal.ZERO) > 0 && newStocked.compareTo(orderQty) < 0) {
                lineStockStatus = 1;
            } else {
                lineStockStatus = 2;
            }
            product.setStockedQuantity(newStocked);
            product.setProductStockStatus(lineStockStatus);
            product.fillRemainingQuantity();
            salesLedgerProductMapper.updateById(product);
        }
        //  按销售订单产品入库情况更新主单入库状态：1-部分入库，2-已入库
        List<SalesLedgerProduct> ledgerAllProducts = salesLedgerProductMapper.selectList(Wrappers.<SalesLedgerProduct>lambdaQuery().eq(SalesLedgerProduct::getSalesLedgerId, ledger.getId()));
        boolean hasStocked = CollectionUtils.isNotEmpty(ledgerAllProducts) && ledgerAllProducts.stream().anyMatch(item -> Objects.equals(item.getProductStockStatus(), 1));
        boolean allStocked = CollectionUtils.isNotEmpty(ledgerAllProducts) && ledgerAllProducts.stream().allMatch(item -> Objects.equals(item.getProductStockStatus(), 1));
        boolean hasStocked = CollectionUtils.isNotEmpty(ledgerAllProducts) && ledgerAllProducts.stream().anyMatch(item -> {
            BigDecimal sq = item.getStockedQuantity();
            return sq != null && sq.compareTo(BigDecimal.ZERO) > 0;
        });
        boolean allStocked = CollectionUtils.isNotEmpty(ledgerAllProducts) && ledgerAllProducts.stream().allMatch(item -> {
            BigDecimal orderQty = item.getQuantity() == null ? BigDecimal.ZERO : item.getQuantity();
            BigDecimal stockedQty = item.getStockedQuantity() == null ? BigDecimal.ZERO : item.getStockedQuantity();
            return orderQty.compareTo(BigDecimal.ZERO) <= 0 || stockedQty.compareTo(orderQty) >= 0;
        });
        ledger.setStockStatus(allStocked ? 2 : (hasStocked ? 1 : 0));
        baseMapper.updateById(ledger);
    }
@@ -1711,4 +1939,298 @@
                .in(Customer::getId, customerIds)
                .orderByAsc(Customer::getCustomerName));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void scanInbound(SalesScanInboundDto dto) {
        if (dto == null || dto.getSalesLedgerId() == null) {
            throw new ServiceException("销售订单入库失败,入库数据不能为空");
        }

        SalesLedger salesLedger = baseMapper.selectById(dto.getSalesLedgerId());
        if (salesLedger == null) {
            throw new ServiceException("入库失败,销售订单不存在");
        }
        if (salesLedger.getStockStatus() == null) {
            throw new ServiceException("入库失败,销售订单状态异常");
        }
        if (salesLedger.getStockStatus() == 2) {
            throw new ServiceException("入库失败,该销售订单已全部入库");
        }
        if (salesLedger.getDeliveryStatus() == 5) {
            throw new ServiceException("入库失败,该销售订单已发货");
        }
        if (CollectionUtils.isEmpty(dto.getSalesLedgerProductList())) {
            throw new ServiceException("销售订单入库失败,入库产品不能为空");
        }
        //  本次入库数量可以大于订单数量,但不能为负
        Map<Long, BigDecimal> inboundQtyByLineId = new LinkedHashMap<>();
        for (SalesLedgerProduct inbound : dto.getSalesLedgerProductList()) {
            if (inbound == null || inbound.getId() == null) {
                throw new ServiceException("入库失败,销售产品信息不完整");
            }
            BigDecimal inboundQty = inbound.getStockedQuantity();
            if (inboundQty == null) {
                throw new ServiceException("入库失败,入库数量不能为空");
            }
            if (inboundQty.compareTo(BigDecimal.ZERO) < 0) {
                throw new ServiceException("入库失败,入库数量不能为负数");
            }
            inboundQtyByLineId.merge(inbound.getId(), inboundQty, BigDecimal::add);
        }
        Long ledgerId = salesLedger.getId();
        for (Map.Entry<Long, BigDecimal> entry : inboundQtyByLineId.entrySet()) {
            Long salesLedgerProductId = entry.getKey();
            BigDecimal inboundThisLine = entry.getValue();
            if (inboundThisLine.compareTo(BigDecimal.ZERO) == 0) {
                continue;
            }
            SalesLedgerProduct dbProduct = salesLedgerProductMapper.selectById(salesLedgerProductId);
            if (dbProduct == null) {
                throw new ServiceException("入库失败,销售产品不存在");
            }
            if (!Objects.equals(dbProduct.getSalesLedgerId(), ledgerId)) {
                throw new ServiceException("入库失败,销售产品与订单不匹配");
            }
            if (!Objects.equals(dbProduct.getType(), SaleEnum.SALE.getCode())) {
                throw new ServiceException("入库失败,仅支持销售订单产品行");
            }
            if (dbProduct.getProductModelId() == null) {
                throw new ServiceException("入库失败,产品规格未维护,无法入库");
            }
            BigDecimal oldStocked = dbProduct.getStockedQuantity() == null ? BigDecimal.ZERO : dbProduct.getStockedQuantity();
            BigDecimal newStocked = oldStocked.add(inboundThisLine);

            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setRecordId(dbProduct.getId());
            stockInventoryDto.setRecordType(StockInQualifiedRecordTypeEnum.SALE_SCAN_STOCK_IN.getCode());
            stockInventoryDto.setQualitity(inboundThisLine);
            stockInventoryDto.setProductModelId(dbProduct.getProductModelId());
            stockInventoryDto.setSalesLedgerId(ledgerId);
            stockInventoryDto.setSalesLedgerProductId(dbProduct.getId());
            stockInventoryService.addstockInventory(stockInventoryDto);

            BigDecimal orderQty = dbProduct.getQuantity() == null ? BigDecimal.ZERO : dbProduct.getQuantity();
            int lineStockStatus;
            if (newStocked.compareTo(BigDecimal.ZERO) <= 0) {
                lineStockStatus = 0;
            } else if (orderQty.compareTo(BigDecimal.ZERO) > 0 && newStocked.compareTo(orderQty) < 0) {
                lineStockStatus = 1;
            } else {
                lineStockStatus = 2;
            }
            dbProduct.setStockedQuantity(newStocked);
            dbProduct.setProductStockStatus(lineStockStatus);
            dbProduct.fillRemainingQuantity();
            salesLedgerProductMapper.updateById(dbProduct);
        }
        List<SalesLedgerProduct> ledgerAllProducts = salesLedgerProductMapper.selectList(
                Wrappers.<SalesLedgerProduct>lambdaQuery().eq(SalesLedgerProduct::getSalesLedgerId, ledgerId));
        boolean anyInbound = ledgerAllProducts.stream().anyMatch(p -> {
            BigDecimal sq = p.getStockedQuantity();
            return sq != null && sq.compareTo(BigDecimal.ZERO) > 0;
        });
        boolean allLinesFull = ledgerAllProducts.stream().allMatch(p -> Objects.equals(p.getProductStockStatus(), 2));
        salesLedger.setStockStatus(allLinesFull ? 2 : (anyInbound ? 1 : 0));
        baseMapper.updateById(salesLedger);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void scanInboundUnqualified(SalesScanInboundDto dto) {
        if (dto == null || dto.getSalesLedgerId() == null) {
            throw new ServiceException("销售订单不合格入库失败,入库数据不能为空");
        }
        SalesLedger salesLedger = baseMapper.selectById(dto.getSalesLedgerId());
        if (salesLedger == null) {
            throw new ServiceException("不合格入库失败,销售订单不存在");
        }
        if (salesLedger.getDeliveryStatus() != null && salesLedger.getDeliveryStatus() == 5) {
            throw new ServiceException("不合格入库失败,该销售订单已发货");
        }
        if (CollectionUtils.isEmpty(dto.getSalesLedgerProductList())) {
            throw new ServiceException("销售订单不合格入库失败,入库产品不能为空");
        }
        Map<Long, BigDecimal> inboundQtyByLineId = new LinkedHashMap<>();
        for (SalesLedgerProduct inbound : dto.getSalesLedgerProductList()) {
            if (inbound == null || inbound.getId() == null) {
                throw new ServiceException("不合格入库失败,销售产品信息不完整");
            }
            BigDecimal inboundQty = inbound.getStockedQuantity();
            if (inboundQty == null) {
                throw new ServiceException("不合格入库失败,入库数量不能为空");
            }
            if (inboundQty.compareTo(BigDecimal.ZERO) < 0) {
                throw new ServiceException("不合格入库失败,入库数量不能为负数");
            }
            inboundQtyByLineId.merge(inbound.getId(), inboundQty, BigDecimal::add);
        }
        Long ledgerId = salesLedger.getId();
        for (Map.Entry<Long, BigDecimal> entry : inboundQtyByLineId.entrySet()) {
            Long salesLedgerProductId = entry.getKey();
            BigDecimal inboundThisLine = entry.getValue();
            if (inboundThisLine.compareTo(BigDecimal.ZERO) == 0) {
                continue;
            }
            SalesLedgerProduct dbProduct = salesLedgerProductMapper.selectById(salesLedgerProductId);
            if (dbProduct == null) {
                throw new ServiceException("不合格入库失败,销售产品不存在");
            }
            if (!Objects.equals(dbProduct.getSalesLedgerId(), ledgerId)) {
                throw new ServiceException("不合格入库失败,销售产品与订单不匹配");
            }
            if (!Objects.equals(dbProduct.getType(), SaleEnum.SALE.getCode())) {
                throw new ServiceException("不合格入库失败,仅支持销售订单产品行");
            }
            if (dbProduct.getProductModelId() == null) {
                throw new ServiceException("不合格入库失败,产品规格未维护,无法入库");
            }
            stockUtils.addUnStock(ledgerId, dbProduct.getId(), dbProduct.getProductModelId(), inboundThisLine,
                    StockInUnQualifiedRecordTypeEnum.SALES_SCAN_UNSTOCK_IN.getCode(), dbProduct.getId());

            BigDecimal oldUnStocked = dbProduct.getUnqualifiedStockedQuantity() == null ? BigDecimal.ZERO : dbProduct.getUnqualifiedStockedQuantity();
            dbProduct.setUnqualifiedStockedQuantity(oldUnStocked.add(inboundThisLine));
            dbProduct.fillRemainingQuantity();
            salesLedgerProductMapper.updateById(dbProduct);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void scanOutbound(SalesScanInboundDto dto) {
        if (dto == null || dto.getSalesLedgerId() == null) {
            throw new ServiceException("销售订单出库失败,出库数据不能为空");
        }
        SalesLedger salesLedger = baseMapper.selectById(dto.getSalesLedgerId());
        if (salesLedger == null) {
            throw new ServiceException("出库失败,销售订单不存在");
        }
        if (salesLedger.getDeliveryStatus() != null && salesLedger.getDeliveryStatus() == 5) {
            throw new ServiceException("出库失败,该销售订单已发货");
        }
        if (CollectionUtils.isEmpty(dto.getSalesLedgerProductList())) {
            throw new ServiceException("销售订单出库失败,出库产品不能为空");
        }
        int saleType = SaleEnum.SALE.getCode();
        Map<Long, BigDecimal> outboundQtyByLineId = new LinkedHashMap<>();
        for (SalesLedgerProduct line : dto.getSalesLedgerProductList()) {
            if (line == null || line.getId() == null) {
                throw new ServiceException("出库失败,销售产品信息不完整");
            }
            BigDecimal outboundQty = line.getStockedQuantity();
            if (outboundQty == null) {
                throw new ServiceException("出库失败,出库数量不能为空");
            }
            if (outboundQty.compareTo(BigDecimal.ZERO) < 0) {
                throw new ServiceException("出库失败,出库数量不能为负数");
            }
            outboundQtyByLineId.merge(line.getId(), outboundQty, BigDecimal::add);
        }
        Long ledgerId = salesLedger.getId();
        for (Map.Entry<Long, BigDecimal> entry : outboundQtyByLineId.entrySet()) {
            Long salesLedgerProductId = entry.getKey();
            BigDecimal outboundThisLine = entry.getValue();
            if (outboundThisLine.compareTo(BigDecimal.ZERO) == 0) {
                continue;
            }
            SalesLedgerProduct dbProduct = salesLedgerProductMapper.selectById(salesLedgerProductId);
            if (dbProduct == null) {
                throw new ServiceException("出库失败,销售产品不存在");
            }
            if (!Objects.equals(dbProduct.getSalesLedgerId(), ledgerId) || !Objects.equals(dbProduct.getType(), saleType)) {
                throw new ServiceException("出库失败,销售产品与订单不匹配");
            }
            if (dbProduct.getProductModelId() == null) {
                throw new ServiceException("出库失败,产品规格未维护,无法出库");
            }
            stockUtils.assertQualifiedAvailable(dbProduct.getProductModelId(), outboundThisLine);

            StockInventoryDto stockInventoryDto = new StockInventoryDto();
            stockInventoryDto.setRecordId(dbProduct.getId());
            stockInventoryDto.setRecordType(StockOutQualifiedRecordTypeEnum.SALE_SCAN_STOCK_OUT.getCode());
            stockInventoryDto.setQualitity(outboundThisLine);
            stockInventoryDto.setProductModelId(dbProduct.getProductModelId());
            stockInventoryDto.setSalesLedgerId(ledgerId);
            stockInventoryDto.setSalesLedgerProductId(dbProduct.getId());
            stockInventoryService.subtractStockInventory(stockInventoryDto);

            BigDecimal oldShipped = dbProduct.getShippedQuantity() == null ? BigDecimal.ZERO : dbProduct.getShippedQuantity();
            dbProduct.setShippedQuantity(oldShipped.add(outboundThisLine));
            dbProduct.fillRemainingQuantity();
            salesLedgerProductMapper.updateById(dbProduct);
        }
        List<SalesLedgerProduct> ledgerAllProducts = salesLedgerProductMapper.selectList(
                Wrappers.<SalesLedgerProduct>lambdaQuery().eq(SalesLedgerProduct::getSalesLedgerId, ledgerId));
        boolean anyInbound = ledgerAllProducts.stream().anyMatch(p -> {
            BigDecimal sq = p.getStockedQuantity();
            return sq != null && sq.compareTo(BigDecimal.ZERO) > 0;
        });
        boolean allLinesFull = ledgerAllProducts.stream().allMatch(p -> Objects.equals(p.getProductStockStatus(), 2));
        salesLedger.setStockStatus(allLinesFull ? 2 : (anyInbound ? 1 : 0));
        baseMapper.updateById(salesLedger);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void scanOutboundUnqualified(SalesScanInboundDto dto) {
        if (dto == null || dto.getSalesLedgerId() == null) {
            throw new ServiceException("销售订单不合格出库失败,出库数据不能为空");
        }
        SalesLedger salesLedger = baseMapper.selectById(dto.getSalesLedgerId());
        if (salesLedger == null) {
            throw new ServiceException("不合格出库失败,销售订单不存在");
        }
        if (salesLedger.getDeliveryStatus() != null && salesLedger.getDeliveryStatus() == 5) {
            throw new ServiceException("不合格出库失败,该销售订单已发货");
        }
        if (CollectionUtils.isEmpty(dto.getSalesLedgerProductList())) {
            throw new ServiceException("销售订单不合格出库失败,出库产品不能为空");
        }
        int saleType = SaleEnum.SALE.getCode();
        Map<Long, BigDecimal> outboundQtyByLineId = new LinkedHashMap<>();
        for (SalesLedgerProduct line : dto.getSalesLedgerProductList()) {
            if (line == null || line.getId() == null) {
                throw new ServiceException("不合格出库失败,销售产品信息不完整");
            }
            BigDecimal outboundQty = line.getStockedQuantity();
            if (outboundQty == null) {
                throw new ServiceException("不合格出库失败,出库数量不能为空");
            }
            if (outboundQty.compareTo(BigDecimal.ZERO) < 0) {
                throw new ServiceException("不合格出库失败,出库数量不能为负数");
            }
            outboundQtyByLineId.merge(line.getId(), outboundQty, BigDecimal::add);
        }
        Long ledgerId = salesLedger.getId();
        for (Map.Entry<Long, BigDecimal> entry : outboundQtyByLineId.entrySet()) {
            Long salesLedgerProductId = entry.getKey();
            BigDecimal outboundThisLine = entry.getValue();
            if (outboundThisLine.compareTo(BigDecimal.ZERO) == 0) {
                continue;
            }
            SalesLedgerProduct dbProduct = salesLedgerProductMapper.selectById(salesLedgerProductId);
            if (dbProduct == null) {
                throw new ServiceException("不合格出库失败,销售产品不存在");
            }
            if (!Objects.equals(dbProduct.getSalesLedgerId(), ledgerId) || !Objects.equals(dbProduct.getType(), saleType)) {
                throw new ServiceException("不合格出库失败,销售产品与订单不匹配");
            }
            if (dbProduct.getProductModelId() == null) {
                throw new ServiceException("不合格出库失败,产品规格未维护,无法出库");
            }
            BigDecimal unStocked = dbProduct.getUnqualifiedStockedQuantity() == null ? BigDecimal.ZERO : dbProduct.getUnqualifiedStockedQuantity();
            BigDecimal unShipped = dbProduct.getUnqualifiedShippedQuantity() == null ? BigDecimal.ZERO : dbProduct.getUnqualifiedShippedQuantity();
            BigDecimal canUnShip = unStocked.subtract(unShipped);
            if (outboundThisLine.compareTo(canUnShip) > 0) {
                throw new ServiceException("不合格出库失败,出库数量不能大于不合格入库数量");
            }
            stockUtils.assertUnqualifiedAvailable(dbProduct.getProductModelId(), outboundThisLine);
            stockUtils.subtractUnStock(ledgerId, dbProduct.getId(), dbProduct.getProductModelId(), outboundThisLine,
                    StockOutUnQualifiedRecordTypeEnum.SALE_SCAN_UNSTOCK_OUT.getCode(), dbProduct.getId());

            dbProduct.setUnqualifiedShippedQuantity(unShipped.add(outboundThisLine));
            dbProduct.fillRemainingQuantity();
            salesLedgerProductMapper.updateById(dbProduct);
        }
    }
}