feat:1.销售，采购，库存，质检模块产品添加批号，供应商 2.销售产品关联批号，供应商递归查询

liding

20 小时以前 1342f568f4b6470efdfc69be7bb153e2b12762f9

 src/main/java/com/ruoyi/stock/service/impl/StockInventoryServiceImpl.java

@@ -1,11 +1,19 @@
package com.ruoyi.stock.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.enums.StockQualifiedRecordTypeEnum;
import com.ruoyi.basic.dto.ProductDto;
import com.ruoyi.basic.dto.ProductTreeDto;
import com.ruoyi.basic.mapper.ProductMapper;
import com.ruoyi.basic.mapper.ProductModelMapper;
import com.ruoyi.basic.pojo.Product;
import com.ruoyi.common.enums.StockInQualifiedRecordTypeEnum;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.sales.mapper.SalesLedgerProductMapper;
@@ -19,15 +27,14 @@
import com.ruoyi.stock.service.StockInRecordService;
import com.ruoyi.stock.service.StockInventoryService;
import com.ruoyi.stock.service.StockOutRecordService;
import lombok.AllArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.*;

/**
 * <p>
@@ -38,13 +45,22 @@
 * @since 2026-01-21 04:16:36
 */
@Service
@AllArgsConstructor
public class StockInventoryServiceImpl extends ServiceImpl<StockInventoryMapper, StockInventory> implements StockInventoryService {

    @Autowired
    private  StockInventoryMapper stockInventoryMapper;
    @Autowired
    private StockInRecordService stockInRecordService;
    @Autowired
    private StockOutRecordService stockOutRecordService;
    @Autowired
    private SalesLedgerProductMapper salesLedgerProductMapper;
    @Autowired
    private ProductMapper productMapper;
    @Autowired
    private ProductModelMapper productModelMapper;


    @Override
    public IPage<StockInventoryDto> pagestockInventory(Page page, StockInventoryDto stockInventoryDto) {
        return stockInventoryMapper.pagestockInventory(page, stockInventoryDto);
@@ -55,16 +71,24 @@
    @Transactional(rollbackFor = Exception.class)
    public Boolean addstockInventory(StockInventoryDto stockInventoryDto) {
        //新增入库记录再添加库存
        StockInRecordDto stockInRecordDto = new StockInRecordDto();
        stockInRecordDto.setRecordId(stockInventoryDto.getRecordId());
        stockInRecordDto.setRecordType(stockInventoryDto.getRecordType());
        stockInRecordDto.setStockInNum(stockInventoryDto.getQualitity());
        stockInRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
        stockInRecordDto.setType("0");
        stockInRecordService.add(stockInRecordDto);
        if (stockInventoryDto.getRecordType() != null) {
            StockInRecordDto stockInRecordDto = new StockInRecordDto();
            stockInRecordDto.setRecordId(stockInventoryDto.getRecordId());
            stockInRecordDto.setRecordType(stockInventoryDto.getRecordType());
            stockInRecordDto.setStockInNum(stockInventoryDto.getQualitity());
            stockInRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
            stockInRecordDto.setType("0");
            stockInRecordDto.setBatchNo(stockInventoryDto.getBatchNo());
            stockInRecordDto.setCustomer(stockInventoryDto.getCustomer());
            stockInRecordService.add(stockInRecordDto);
        }
        //再进行新增库存数量库存
        //先查询库存表中的产品是否存在，不存在新增，存在更新
        StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda().eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId()));
        StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda()
                .eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId())
                .eq(StockInventory::getBatchNo, stockInventoryDto.getBatchNo())
                .eq(StockInventory::getCustomer, stockInventoryDto.getCustomer())
        );
        if (ObjectUtils.isEmpty(oldStockInventory)) {
            StockInventory newStockInventory = new StockInventory();
            newStockInventory.setProductModelId(stockInventoryDto.getProductModelId());
@@ -73,6 +97,8 @@
            newStockInventory.setRemark(stockInventoryDto.getRemark());
            newStockInventory.setLockedQuantity(stockInventoryDto.getLockedQuantity());
            newStockInventory.setWarnNum(stockInventoryDto.getWarnNum());
            newStockInventory.setBatchNo(stockInventoryDto.getBatchNo());
            newStockInventory.setCustomer(stockInventoryDto.getCustomer());
            stockInventoryMapper.insert(newStockInventory);
        }else {
             stockInventoryMapper.updateAddStockInventory(stockInventoryDto);
@@ -85,14 +111,25 @@
    @Transactional(rollbackFor = Exception.class)
    public Boolean subtractStockInventory(StockInventoryDto stockInventoryDto) {
        //  新增出库记录
        StockOutRecordDto stockOutRecordDto = new StockOutRecordDto();
        stockOutRecordDto.setRecordId(stockInventoryDto.getRecordId());
        stockOutRecordDto.setRecordType(stockInventoryDto.getRecordType());
        stockOutRecordDto.setStockOutNum(stockInventoryDto.getQualitity());
        stockOutRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
        stockOutRecordDto.setType("0");
        stockOutRecordService.add(stockOutRecordDto);
        StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda().eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId()));
        if (stockInventoryDto.getRecordType() != null) {
            StockOutRecordDto stockOutRecordDto = new StockOutRecordDto();
            stockOutRecordDto.setRecordId(stockInventoryDto.getRecordId());
            stockOutRecordDto.setRecordType(stockInventoryDto.getRecordType());
            stockOutRecordDto.setStockOutNum(stockInventoryDto.getQualitity());
            stockOutRecordDto.setProductModelId(stockInventoryDto.getProductModelId());
            stockOutRecordDto.setBatchNo(stockInventoryDto.getBatchNo());
            stockOutRecordDto.setCustomer(stockInventoryDto.getCustomer());
            stockOutRecordDto.setType("0");
            stockOutRecordService.add(stockOutRecordDto);
        }
        StockInventory oldStockInventory = stockInventoryMapper.selectOne(new QueryWrapper<StockInventory>().lambda()
                .eq(StockInventory::getProductModelId, stockInventoryDto.getProductModelId())
                .eq(StockInventory::getBatchNo, stockInventoryDto.getBatchNo())
                .eq(StockInventory::getCustomer, stockInventoryDto.getCustomer())
        );
        if (ObjectUtils.isEmpty(oldStockInventory)) {
            throw new RuntimeException("产品库存不存在");
        }
        BigDecimal lockedQty = oldStockInventory.getLockedQuantity();
        if (lockedQty == null) {
            lockedQty = BigDecimal.ZERO;
@@ -101,11 +138,7 @@
            throw new RuntimeException("库存不足无法出库");
        }

        if (ObjectUtils.isEmpty(oldStockInventory)) {
            throw new RuntimeException("产品库存不存在");
        } else {
            stockInventoryMapper.updateSubtractStockInventory(stockInventoryDto);
        }
        stockInventoryMapper.updateSubtractStockInventory(stockInventoryDto);
        return true;
    }

@@ -128,7 +161,7 @@
                            item.getSpecificationModel().equals(dto.getModel())) {
                        StockInventoryDto stockInventoryDto = new StockInventoryDto();
                        stockInventoryDto.setRecordId(0L);
                        stockInventoryDto.setRecordType(StockQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_IN.getCode());
                        stockInventoryDto.setRecordType(StockInQualifiedRecordTypeEnum.CUSTOMIZATION_STOCK_IN.getCode());
                        stockInventoryDto.setQualitity(dto.getQualitity());
                        stockInventoryDto.setRemark(dto.getRemark());
                        stockInventoryDto.setWarnNum(dto.getWarnNum());
@@ -207,4 +240,216 @@
        stockInventory.setLockedQuantity(stockInventory.getLockedQuantity().subtract(stockInventoryDto.getLockedQuantity()));
        return this.updateById(stockInventory);
    }

    @Override
    public List<StockInventoryDto> getMaterials(StockInventoryDto stockInventoryDto) {
        return stockInventoryMapper.getMaterials(stockInventoryDto);
    }

    @Override
    public List<ProductTreeDto> getStockInventoryAll(ProductDto productDto) {
        // 查询库存列表
        List<StockInventoryDto> stockList = stockInventoryMapper.getStockInventoryAll(productDto);

        if (CollectionUtils.isEmpty(stockList)) {
            return new ArrayList<>();
        }

        // 构建产品树（基于产品表的父子关系）
        Map<Long, ProductTreeDto> productNodeMap = buildProductTree(stockList);

        // 将库存数据（型号->批次->客户）挂载到对应的产品节点下
        attachStockDataToProduct(productNodeMap, stockList);

        // 返回根节点
        List<ProductTreeDto> tree = new ArrayList<>();
        for (ProductTreeDto node : productNodeMap.values()) {
            if (node.getParentId() == null || node.getParentId() == 0) {
                tree.add(node);
            }
        }

        return tree;
    }

    /**
     * 构建产品树（自动递归查询所有父级，包含根节点）
     */
    private Map<Long, ProductTreeDto> buildProductTree(List<StockInventoryDto> stockList) {
        // 1. 收集所有需要加载的产品ID
        Set<Long> needQueryIds = new HashSet<>();
        for (StockInventoryDto stock : stockList) {
            if (stock.getProductId() != null) {
                needQueryIds.add(stock.getProductId());
            }
        }

        // 递归查询所有节点（直到根节点）
        Set<Long> allAncestors = getAllAncestorIds(needQueryIds);
        needQueryIds.addAll(allAncestors);

        // 批量查询所有产品（包含完整层级）
        LambdaQueryWrapper<Product> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Product::getId, needQueryIds);
        List<Product> products = productMapper.selectList(wrapper);

        // 构建节点Map
        Map<Long, ProductTreeDto> nodeMap = new HashMap<>();
        for (Product product : products) {
            ProductTreeDto node = new ProductTreeDto();
            node.setId(product.getId());
            node.setParentId(product.getParentId());
            node.setProductName(product.getProductName());
            node.setLabel(product.getProductName());
            node.setNodeType("product");
            node.setChildren(new ArrayList<>());
            nodeMap.put(product.getId(), node);
        }

        // 构建父子关系
        for (ProductTreeDto node : nodeMap.values()) {
            Long parentId = node.getParentId();
            if (parentId != null && parentId != 0 && nodeMap.containsKey(parentId)) {
                nodeMap.get(parentId).getChildren().add(node);
            }
        }

        return nodeMap;
    }

    /**
     * 递归查询所有产品的祖先ID（直到根节点）
     */
    private Set<Long> getAllAncestorIds(Set<Long> productIds) {
        Set<Long> ancestorIds = new HashSet<>();
        Queue<Long> queue = new LinkedList<>(productIds);

        while (!queue.isEmpty()) {
            Long currentId = queue.poll();
            Product product = productMapper.selectById(currentId);
            if (product == null) continue;

            Long parentId = product.getParentId();
            if (parentId != null && parentId != 0 && !ancestorIds.contains(parentId)) {
                ancestorIds.add(parentId);
                queue.add(parentId);
            }
        }
        return ancestorIds;
    }

    /**
     * 将库存数据（型号->批次->客户）挂载到产品节点下
     */
    private void attachStockDataToProduct(Map<Long, ProductTreeDto> productNodeMap,
                                          List<StockInventoryDto> stockList) {
        for (StockInventoryDto stock : stockList) {
            Long productId = stock.getProductId();
            if (productId == null || !productNodeMap.containsKey(productId)) {
                continue;
            }

            ProductTreeDto productNode = productNodeMap.get(productId);

            // 构建该产品的库存树（型号 -> 批次 -> 客户）
            ProductTreeDto stockTree = buildStockTree(stock);

            // 合并到产品节点的 children 中
            mergeStockTree(productNode.getChildren(), stockTree);
        }
    }

    /**
     * 构建单个库存的树结构（型号 -> 批次 -> 客户）
     */
    private ProductTreeDto buildStockTree(StockInventoryDto stock) {
        // 型号节点
        ProductTreeDto modelNode = new ProductTreeDto();
        modelNode.setModel(stock.getModel());
        modelNode.setUidNo(stock.getUidNo());
        modelNode.setUnit(stock.getUnit());
        modelNode.setProductModelId(stock.getProductModelId());
        modelNode.setLabel(stock.getModel());
        modelNode.setNodeType("model");
        modelNode.setChildren(new ArrayList<>());

        // 批次节点
        ProductTreeDto batchNode = new ProductTreeDto();
        String batchNo = StringUtils.isBlank(stock.getBatchNo()) ? "无批次" : stock.getBatchNo();
        batchNode.setBatchNo(batchNo);
        batchNode.setLabel("批次: " + batchNo);
        batchNode.setNodeType("batch");
        batchNode.setChildren(new ArrayList<>());

        // 客户节点
        ProductTreeDto customerNode = new ProductTreeDto();
        String customer = StringUtils.isBlank(stock.getCustomer()) ? "无客户" : stock.getCustomer();
        customerNode.setCustomer(customer);
        customerNode.setLabel(customer);
        customerNode.setNodeType("customer");
        customerNode.setChildren(new ArrayList<>());

        batchNode.getChildren().add(customerNode);
        modelNode.getChildren().add(batchNode);

        return modelNode;
    }

    /**
     * 合并库存树到产品节点的 children 中
     */
    private void mergeStockTree(List<ProductTreeDto> children, ProductTreeDto newStockTree) {
        if (children == null) {
            return;
        }

        // 查找是否已有相同型号的节点
        ProductTreeDto existingModelNode = null;
        for (ProductTreeDto child : children) {
            if (child.getNodeType().equals("model") &&
                    child.getModel() != null &&
                    child.getModel().equals(newStockTree.getModel())) {
                existingModelNode = child;
                break;
            }
        }

        if (existingModelNode == null) {
            // 没有相同型号，直接添加
            children.add(newStockTree);
        } else {
            // 有相同型号，合并批次节点
            ProductTreeDto newBatchNode = newStockTree.getChildren().get(0);

            // 查找是否已有相同批次
            ProductTreeDto existingBatchNode = null;
            for (ProductTreeDto batchChild : existingModelNode.getChildren()) {
                if (batchChild.getNodeType().equals("batch") &&
                        batchChild.getBatchNo() != null &&
                        batchChild.getBatchNo().equals(newBatchNode.getBatchNo())) {
                    existingBatchNode = batchChild;
                    break;
                }
            }

            if (existingBatchNode == null) {
                existingModelNode.getChildren().add(newBatchNode);
            } else {
                // 合并客户节点
                ProductTreeDto newCustomerNode = newBatchNode.getChildren().get(0);
                boolean customerExists = false;
                for (ProductTreeDto customerChild : existingBatchNode.getChildren()) {
                    if (customerChild.getNodeType().equals("customer") &&
                            customerChild.getCustomer() != null &&
                            customerChild.getCustomer().equals(newCustomerNode.getCustomer())) {
                        customerExists = true;
                        break;
                    }
                }
                if (!customerExists) {
                    existingBatchNode.getChildren().add(newCustomerNode);
                }
            }
        }
    }
}