feat(basic): 添加产品条码功能并完善生产统计报表

云

7 天以前 1e123568c2f561013f5636e45dc0db30b17a3517

 src/main/java/com/ruoyi/technology/service/impl/TechnologyBomServiceImpl.java

@@ -1,5 +1,6 @@
package com.ruoyi.technology.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -11,13 +12,22 @@
import com.ruoyi.basic.service.IProductService;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.web.domain.R;
import com.ruoyi.production.bean.dto.BomImportDto;
import com.ruoyi.production.bean.dto.ProductStructureDto;
import com.ruoyi.procurementrecord.pojo.ProcurementDemand;
import com.ruoyi.procurementrecord.service.ProcurementDemandService;
import com.ruoyi.stock.mapper.StockInventoryMapper;
import com.ruoyi.stock.pojo.StockInventory;
import com.ruoyi.technology.bean.dto.BomImportDto;
import com.ruoyi.technology.bean.dto.BomKitCheckDto;
import com.ruoyi.technology.bean.dto.TechnologyBomDto;
import com.ruoyi.technology.bean.dto.TechnologyBomStructureDto;
import com.ruoyi.technology.bean.vo.BomKitCheckItemVo;
import com.ruoyi.technology.bean.vo.TechnologyBomStructureVo;
import com.ruoyi.technology.bean.vo.TechnologyBomVo;
import com.ruoyi.technology.mapper.TechnologyBomMapper;
import com.ruoyi.technology.mapper.TechnologyBomStructureMapper;
import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
import com.ruoyi.technology.pojo.TechnologyBom;
import com.ruoyi.technology.pojo.TechnologyBomStructure;
@@ -32,6 +42,7 @@

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;

@Service
@@ -43,6 +54,9 @@
    private final TechnologyBomStructureService technologyBomStructureService;
    private final TechnologyRoutingMapper technologyRoutingMapper;
    private final IProductService productService;
    private final TechnologyBomStructureMapper technologyBomStructureMapper;
    private final StockInventoryMapper stockInventoryMapper;
    private final ProcurementDemandService procurementDemandService;

    /**
     * 分页查询BOM列表。
@@ -84,12 +98,18 @@
    @Transactional(rollbackFor = Exception.class)
    public R add(TechnologyBom technologyBom) {
        validateProductModel(technologyBom.getProductModelId());
        if (technologyBom.getStatus() == null) {
            technologyBom.setStatus(1);
        }
        boolean saved = technologyBomMapper.insert(technologyBom) > 0;
        if (!saved) {
            return R.fail("Add BOM failed");
        }
        technologyBom.setBomNo("BM." + String.format("%05d", technologyBom.getId()));
        technologyBomMapper.updateById(technologyBom);
        if (Integer.valueOf(1).equals(technologyBom.getStatus())) {
            deactivateOtherVersions(technologyBom.getProductModelId(), technologyBom.getId().longValue());
        }
        initRootStructure(technologyBom.getId().longValue(), technologyBom.getProductModelId());
        return R.ok();
    }
@@ -101,12 +121,12 @@
    @Transactional(rollbackFor = Exception.class)
    public R update(TechnologyBom technologyBom) {
        if (technologyBom.getId() == null) {
            throw new ServiceException("BOM id is required");
            throw new ServiceException("BOM ID不能为空");
        }
        validateProductModel(technologyBom.getProductModelId());
        TechnologyBom oldBom = technologyBomMapper.selectById(technologyBom.getId());
        if (oldBom == null) {
            throw new ServiceException("BOM not found");
            throw new ServiceException("BOM不存在");
        }
        if (oldBom.getProductModelId() != null && !oldBom.getProductModelId().equals(technologyBom.getProductModelId())) {
            technologyRoutingMapper.updateProductModelByBomId(technologyBom.getProductModelId(), technologyBom.getId().longValue());
@@ -118,7 +138,24 @@
            technologyBom.setBomNo(oldBom.getBomNo());
        }
        technologyBomMapper.updateById(technologyBom);
        if (Integer.valueOf(1).equals(technologyBom.getStatus())) {
            deactivateOtherVersions(technologyBom.getProductModelId(), technologyBom.getId().longValue());
        }
        return R.ok();
    }

    /**
     * 同一产品规格只保留一个启用版本
     */
    private void deactivateOtherVersions(Long productModelId, Long keepId) {
        if (productModelId == null) {
            return;
        }
        technologyBomMapper.update(null, Wrappers.<TechnologyBom>lambdaUpdate()
                .set(TechnologyBom::getStatus, 0)
                .eq(TechnologyBom::getProductModelId, productModelId)
                .ne(TechnologyBom::getId, keepId)
                .eq(TechnologyBom::getStatus, 1));
    }

    /**
@@ -128,12 +165,12 @@
    @Transactional(rollbackFor = Exception.class)
    public boolean batchDelete(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new ServiceException("Select at least one BOM");
            throw new ServiceException("请至少选择一个BOM");
        }
        List<TechnologyRouting> list = technologyRoutingMapper.selectList(Wrappers.<TechnologyRouting>lambdaQuery()
                .in(TechnologyRouting::getBomId, ids));
        if (!list.isEmpty()) {
            throw new ServiceException("BOM is referenced by routing");
            throw new ServiceException("BOM已被工艺路线引用，不能删除");
        }
        technologyBomStructureService.remove(Wrappers.<TechnologyBomStructure>lambdaQuery()
                .in(TechnologyBomStructure::getBomId, ids));
@@ -145,11 +182,11 @@
     */
    private void validateProductModel(Long productModelId) {
        if (productModelId == null) {
            throw new ServiceException("Product model is required");
            throw new ServiceException("产品规格ID不能为空");
        }
        ProductModel productModel = productModelService.getById(productModelId);
        if (productModel == null) {
            throw new ServiceException("Product model not found");
            throw new ServiceException("产品规格不存在");
        }
    }

@@ -256,70 +293,100 @@


    @Override
    public void exportBom(HttpServletResponse response, Integer bomId) {
    public void exportBom(HttpServletResponse response, Long bomId) {
        if (bomId == null) {
            throw new ServiceException("BOM ID不能为空");
        }

        List<TechnologyBomStructureVo> treeData = technologyBomStructureService.listByBomId(bomId);
        if (treeData == null || treeData.isEmpty()) {
            return;
        }

//        List<ProductStructureDto> treeData = productStructureService.listBybomId(bomId);
//        if (treeData == null || treeData.isEmpty()) {
//            return;
//        }
//
//        //  将树形结构扁平化 使用 BFS算法 导出,按层级顺序
//        List<BomImportDto> exportList = new ArrayList<>();
//
//        // Map<ID, Node> idMap 用于查找父节点
//        Map<Long, ProductStructureDto> idMap = new HashMap<>();
//        populateMap(treeData, idMap);
//
//        //  treeData 的第一个是根节点
//        for (ProductStructureDto root : treeData) {
//            //  添加根节点
//            BomImportDto rootRow = new BomImportDto();
//            rootRow.setParentName(root.getProductName());
//            rootRow.setParentSpec(root.getModel());
//            rootRow.setUnitQty(root.getUnitQuantity());
//            rootRow.setRemark("");
//            exportList.add(rootRow);
//
//            //  BFS 遍历-队列
//            Queue<ProductStructureDto> queue = new LinkedList<>();
//            if (root.getChildren() != null) {
//                queue.addAll(root.getChildren());
//            }
//
//            while (!queue.isEmpty()) {
//                ProductStructureDto child = queue.poll();
//
//                // 查找父节点
//                ProductStructureDto parent = idMap.get(child.getParentId());
//                if (parent == null) {
//                    // 除了最外层节点,其他节点的父类肯定是不会为空的
//                    continue;
//                }
//
//                BomImportDto row = new BomImportDto();
//                // 父类信息
//                row.setParentName(parent.getProductName());
//                row.setParentSpec(parent.getModel());
//                // 子类信息
//                row.setChildName(child.getProductName());
//                row.setChildSpec(child.getModel());
//                row.setUnitQty(child.getUnitQuantity());
//                row.setProcess(child.getProcessName());
//
//                exportList.add(row);
//
//                //  将子节点的子节点加入队列-下一层
//                if (child.getChildren() != null && !child.getChildren().isEmpty()) {
//                    queue.addAll(child.getChildren());
//                }
//            }
//        }
        //  将树形结构扁平化 使用 BFS算法 导出,按层级顺序
        List<BomImportDto> exportList = new ArrayList<>();

        // Map<ID, Node> idMap 用于查找父节点
        Map<Long, TechnologyBomStructureVo> idMap = new HashMap<>();
        populateMap(treeData, idMap);

        //  treeData 的第一个是根节点
        for (TechnologyBomStructureVo root : treeData) {
            //  添加根节点
            BomImportDto rootRow = new BomImportDto();
            rootRow.setParentName(root.getProductName());
            rootRow.setParentSpec(root.getModel());
            rootRow.setUnitQty(root.getUnitQuantity());
            rootRow.setParentCode(root.getProductCode());
            rootRow.setRemark("");
            exportList.add(rootRow);

            //  BFS 遍历-队列
            Queue<TechnologyBomStructureVo> queue = new LinkedList<>();
            if (root.getChildren() != null) {
                queue.addAll(root.getChildren());
            }

            while (!queue.isEmpty()) {
                TechnologyBomStructureVo child = queue.poll();

                // 查找父节点
                TechnologyBomStructureVo parent = idMap.get(child.getParentId());
                if (parent == null) {
                    // 除了最外层节点,其他节点的父类肯定是不会为空的
                    continue;
                }

                BomImportDto row = new BomImportDto();
                // 父类信息
                row.setParentName(parent.getProductName());
                row.setParentSpec(parent.getModel());
                // 子类信息
                row.setChildName(child.getProductName());
                row.setChildSpec(child.getModel());
                row.setUnitQty(child.getUnitQuantity());
                row.setProcess(child.getOperationName());
                row.setChildCode(child.getProductCode());

                exportList.add(row);

                //  将子节点的子节点加入队列-下一层
                if (child.getChildren() != null && !child.getChildren().isEmpty()) {
                    queue.addAll(child.getChildren());
                }
            }
        }

        ExcelUtil<BomImportDto> util = new ExcelUtil<>(BomImportDto.class);
//        util.exportExcel(response, exportList, "BOM结构导出");
        util.exportExcel(response, exportList, "BOM结构导出");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R copy(TechnologyBom technologyBom) {
        TechnologyBom oldTechnologyBom = technologyBomMapper.selectById(technologyBom.getId());
        List<TechnologyBomStructureVo> oldTechnologyBomStructureVos = technologyBomStructureService.listByBomId(technologyBom.getId().longValue());
        //校验产品规格是否存在。
        validateProductModel(oldTechnologyBom.getProductModelId());
        TechnologyBom newTechnologyBom = new TechnologyBom();
        newTechnologyBom.setProductModelId(oldTechnologyBom.getProductModelId());
        newTechnologyBom.setVersion("FZ" + oldTechnologyBom.getVersion());
        newTechnologyBom.setRemark(oldTechnologyBom.getRemark());
        newTechnologyBom.setStatus(0);
        boolean saved = technologyBomMapper.insert(newTechnologyBom) > 0;
        if (!saved) {
            return R.fail("Copy BOM failed");
        }
        newTechnologyBom.setBomNo("BM." + String.format("%05d", newTechnologyBom.getId()));
        technologyBomMapper.updateById(newTechnologyBom);
        //初始化BOM根节点结构。
        initRootStructure(newTechnologyBom.getId().longValue(), newTechnologyBom.getProductModelId());
        //把产品结构里面的数据也全部都复制
        TechnologyBomStructureVo technologyBomStructureVo = oldTechnologyBomStructureVos.get(0);
        TechnologyBomStructureDto technologyBomStructureDto = convertTree(technologyBomStructureVo);
        technologyBomStructureDto.setBomId(newTechnologyBom.getId().longValue());
        technologyBomStructureService.addTechnologyBomStructure(technologyBomStructureDto);
        return R.ok();
    }

    private ProductModel findModel(String name, String spec) {
@@ -374,13 +441,223 @@
        return s.replaceAll("[\\u00A0\\u3000]", "").trim();
    }

    private void populateMap(List<ProductStructureDto> nodes, Map<Long, ProductStructureDto> map) {
    private void populateMap(List<TechnologyBomStructureVo> nodes, Map<Long, TechnologyBomStructureVo> map) {
        if (nodes == null || nodes.isEmpty()) {
            return;
        }
        for (ProductStructureDto node : nodes) {
        for (TechnologyBomStructureVo node : nodes) {
            map.put(node.getId(), node);
            populateMap(node.getChildren(), map);
        }
    }

    /**
     * 递归转换树形结构 VO -> DTO
     * 自动生成虚拟 tempId / parentTempId，保证任意层级树结构正确
     */
    public static TechnologyBomStructureDto convertTree(TechnologyBomStructureVo vo) {
        if (vo == null) {
            return null;
        }
        TechnologyBomStructureDto realDto = convertNode(vo, "0"); // 根节点父ID=0（纯数字）
        TechnologyBomStructureDto rootDto = new TechnologyBomStructureDto();
        rootDto.setTempId("0");
        rootDto.setChildren(Collections.singletonList(realDto));

        return rootDto;
    }

    /**
     * 核心递归方法
     * @param vo 原始节点
     * @param parentTempId 父节点 纯数字ID
     * @return 转换后DTO
     */
    private static TechnologyBomStructureDto convertNode(TechnologyBomStructureVo vo, String parentTempId) {
        if (vo == null) {
            return null;
        }

        TechnologyBomStructureDto dto = new TechnologyBomStructureDto();
        BeanUtils.copyProperties(vo, dto);

        String currentTempId = getNumberId();
        dto.setTempId(currentTempId);
        dto.setParentTempId(parentTempId);


        dto.setId(null);
        dto.setParentId(null);

        // ===================== 递归子节点 =====================
        List<TechnologyBomStructureVo> voChildren = vo.getChildren();
        if (CollUtil.isNotEmpty(voChildren)) {
            List<TechnologyBomStructureDto> dtoChildren = new ArrayList<>();
            for (TechnologyBomStructureVo childVo : voChildren) {
                // 子节点的父ID = 当前节点的数字ID
                dtoChildren.add(convertNode(childVo, currentTempId));
            }
            dto.setChildren(dtoChildren);
        } else {
            dto.setChildren(new ArrayList<>());
        }

        return dto;
    }

    /**
     * 生成 13位 纯数字随机ID（安全、不重复、高性能）
     */
    private static String getNumberId() {
        // 生成 1000000000000 ~ 9999999999999 之间的数字
        long min = 1000000000000L;
        long max = 9999999999999L;
        long randomNum = ThreadLocalRandom.current().nextLong(min, max + 1);
        return String.valueOf(randomNum);
    }

    /**
     * BOM齐套分析：逐层展开树（需求量=父需求×单位用量），按规格汇总后与可用库存比对。
     * 可用库存 = Σ(库存数量 - 锁定数量)，缺口 = max(需求量 - 可用库存, 0)。
     */
    @Override
    public List<BomKitCheckItemVo> kitCheck(BomKitCheckDto dto) {
        if (dto == null || dto.getBomId() == null || dto.getDemandQty() == null
                || dto.getDemandQty().compareTo(BigDecimal.ZERO) <= 0) {
            throw new ServiceException("请传入bomId和需求数量(须大于0)");
        }
        TechnologyBom bom = technologyBomMapper.selectById(dto.getBomId());
        if (bom == null) {
            throw new ServiceException("BOM不存在");
        }
        List<TechnologyBomStructureVo> roots = technologyBomStructureService.listByBomId(dto.getBomId());
        if (CollUtil.isEmpty(roots)) {
            throw new ServiceException("BOM结构为空，请先维护物料清单");
        }

        Map<Long, BigDecimal> requiredMap = new LinkedHashMap<>();
        for (TechnologyBomStructureVo root : roots) {
            expandRequirements(root, dto.getDemandQty(), requiredMap, true);
        }
        if (requiredMap.isEmpty()) {
            throw new ServiceException("BOM下无物料节点");
        }

        Map<Long, BigDecimal> availMap = new HashMap<>();
        List<StockInventory> stocks = stockInventoryMapper.selectList(Wrappers.<StockInventory>lambdaQuery()
                .in(StockInventory::getProductModelId, requiredMap.keySet()));
        for (StockInventory s : stocks) {
            BigDecimal avail = s.getQualitity() == null ? BigDecimal.ZERO : s.getQualitity();
            avail = avail.subtract(s.getLockedQuantity() == null ? BigDecimal.ZERO : s.getLockedQuantity());
            availMap.merge(s.getProductModelId(), avail, BigDecimal::add);
        }

        List<ProductModel> models = productModelService.listByIds(requiredMap.keySet());
        Map<Long, ProductModel> modelMap = models.stream()
                .collect(Collectors.toMap(ProductModel::getId, m -> m, (a, b) -> a));
        Map<Long, String> productNameMap = new HashMap<>();
        Set<Long> productIds = models.stream().map(ProductModel::getProductId)
                .filter(Objects::nonNull).collect(Collectors.toSet());
        if (!productIds.isEmpty()) {
            productService.listByIds(productIds)
                    .forEach(p -> productNameMap.put(p.getId().longValue(), p.getProductName()));
        }

        List<BomKitCheckItemVo> result = new ArrayList<>();
        for (Map.Entry<Long, BigDecimal> entry : requiredMap.entrySet()) {
            BigDecimal required = entry.getValue();
            BigDecimal available = availMap.getOrDefault(entry.getKey(), BigDecimal.ZERO);
            ProductModel pm = modelMap.get(entry.getKey());
            BomKitCheckItemVo vo = new BomKitCheckItemVo();
            vo.setProductModelId(entry.getKey());
            vo.setProductName(pm == null ? null : productNameMap.get(pm.getProductId()));
            vo.setModel(pm == null ? null : pm.getModel());
            vo.setUnit(pm == null ? null : pm.getUnit());
            vo.setRequiredQty(required);
            vo.setAvailableQty(available);
            vo.setShortageQty(required.subtract(available).max(BigDecimal.ZERO));
            result.add(vo);
        }
        result.sort(Comparator.comparing(BomKitCheckItemVo::getShortageQty).reversed());
        return result;
    }

    private void expandRequirements(TechnologyBomStructureVo node, BigDecimal requiredQty,
                                    Map<Long, BigDecimal> requiredMap, boolean isRoot) {
        if (!isRoot && node.getProductModelId() != null) {
            requiredMap.merge(node.getProductModelId(), requiredQty, BigDecimal::add);
        }
        if (CollUtil.isNotEmpty(node.getChildren())) {
            for (TechnologyBomStructureVo child : node.getChildren()) {
                BigDecimal unitQty = child.getUnitQuantity() == null ? BigDecimal.ZERO : child.getUnitQuantity();
                expandRequirements(child, requiredQty.multiply(unitQty), requiredMap, false);
            }
        }
    }

    /**
     * 将缺口物料写入采购需求：同规格已存在待处理记录则累加缺口，否则新增。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R generateProcurementDemand(BomKitCheckDto dto) {
        List<BomKitCheckItemVo> items = kitCheck(dto);
        List<BomKitCheckItemVo> shortages = items.stream()
                .filter(item -> item.getShortageQty().compareTo(BigDecimal.ZERO) > 0)
                .collect(Collectors.toList());
        if (shortages.isEmpty()) {
            return R.ok("库存齐套，无需生成采购需求");
        }
        TechnologyBom bom = technologyBomMapper.selectById(dto.getBomId());
        int created = 0;
        int merged = 0;
        for (BomKitCheckItemVo item : shortages) {
            ProcurementDemand exist = procurementDemandService.getOne(Wrappers.<ProcurementDemand>lambdaQuery()
                    .eq(ProcurementDemand::getProductModelId, item.getProductModelId())
                    .eq(ProcurementDemand::getStatus, 0)
                    .last("limit 1"));
            if (exist != null) {
                exist.setDemandQuantity(exist.getDemandQuantity().add(item.getShortageQty()));
                exist.setStockQuantity(item.getAvailableQty());
                exist.setSourceBomId(dto.getBomId());
                exist.setSourceBomNo(bom == null ? null : bom.getBomNo());
                procurementDemandService.updateById(exist);
                merged++;
            } else {
                ProcurementDemand demand = new ProcurementDemand();
                demand.setProductModelId(item.getProductModelId());
                demand.setProductName(item.getProductName());
                demand.setProductModel(item.getModel());
                demand.setUnit(item.getUnit());
                demand.setDemandQuantity(item.getShortageQty());
                demand.setStockQuantity(item.getAvailableQty());
                demand.setSourceBomId(dto.getBomId());
                demand.setSourceBomNo(bom == null ? null : bom.getBomNo());
                demand.setStatus(0);
                procurementDemandService.save(demand);
                created++;
            }
        }
        return R.ok(String.format("采购需求生成完成：新增 %d 条，累加合并 %d 条", created, merged));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R changeStatus(Integer id, Integer status) {
        if (id == null || status == null || (status != 0 && status != 1)) {
            return R.fail("参数错误：需传入id和状态(1启用/0停用)");
        }
        TechnologyBom bom = technologyBomMapper.selectById(id);
        if (bom == null) {
            return R.fail("BOM不存在");
        }
        TechnologyBom update = new TechnologyBom();
        update.setId(id);
        update.setStatus(status);
        technologyBomMapper.updateById(update);
        if (Integer.valueOf(1).equals(status)) {
            deactivateOtherVersions(bom.getProductModelId(), id.longValue());
        }
        return R.ok();
    }
}