fix: 添加条件过滤以确保查询结果中合格数量大于零

yuan

2 天以前 6f0df10fdd0e55e5ed3e31b1720efd25e2bf02fb

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

@@ -1,6 +1,5 @@
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;
@@ -12,20 +11,18 @@
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.technology.bean.dto.BomImportDto;
import com.ruoyi.technology.bean.dto.TechnologyBomDto;
import com.ruoyi.technology.bean.dto.TechnologyBomStructureDto;
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.TechnologyOperationMapper;
import com.ruoyi.technology.mapper.TechnologyRoutingMapper;
import com.ruoyi.technology.pojo.TechnologyBom;
import com.ruoyi.technology.pojo.TechnologyBomStructure;
import com.ruoyi.technology.pojo.TechnologyOperation;
import com.ruoyi.technology.pojo.TechnologyRouting;
import com.ruoyi.technology.service.TechnologyBomService;
import com.ruoyi.technology.service.TechnologyBomStructureService;
@@ -35,10 +32,12 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

@Service
@RequiredArgsConstructor
@@ -49,7 +48,7 @@
    private final TechnologyBomStructureService technologyBomStructureService;
    private final TechnologyRoutingMapper technologyRoutingMapper;
    private final IProductService productService;
    private final TechnologyBomStructureMapper technologyBomStructureMapper;
    private final TechnologyOperationMapper technologyOperationMapper;

    /**
     * 分页查询BOM列表。
@@ -85,7 +84,7 @@
    }

    /**
     * 新增BOM并初始化根结构节点。
     * 新增BOM。BOM主表本身即代表成品规格，明细表不再写入成品根节点。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -97,29 +96,29 @@
        }
        technologyBom.setBomNo("BM." + String.format("%05d", technologyBom.getId()));
        technologyBomMapper.updateById(technologyBom);
        initRootStructure(technologyBom.getId().longValue(), technologyBom.getProductModelId());
        return R.ok();
    }

    /**
     * 修改BOM，规格变化时同步刷新关联结构与路线数据。
     * 修改BOM。成品规格变化时同步刷新工艺路线的成品规格，
     * 并清理与新成品规格冲突的物料行（成品不能作为自身物料），其余物料-工序关系保留。
     */
    @Override
    @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());
            technologyBomStructureService.remove(Wrappers.<TechnologyBomStructure>lambdaQuery()
                    .eq(TechnologyBomStructure::getBomId, technologyBom.getId().longValue()));
            initRootStructure(technologyBom.getId().longValue(), technologyBom.getProductModelId());
                    .eq(TechnologyBomStructure::getBomId, technologyBom.getId().longValue())
                    .eq(TechnologyBomStructure::getProductModelId, technologyBom.getProductModelId()));
        }
        if (technologyBom.getBomNo() == null) {
            technologyBom.setBomNo(oldBom.getBomNo());
@@ -135,12 +134,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));
@@ -152,28 +151,18 @@
     */
    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("产品规格不存在");
        }
    }

    /**
     * 初始化BOM根节点结构。
     * 导入扁平BOM：每行 = 成品 + 一个物料规格 + 消耗工序。
     * 同一次导入的所有行必须属于同一个成品；旧的父子/单位用量模板会被明确拒绝。
     */
    private void initRootStructure(Long bomId, Long productModelId) {
        ProductModel productModel = productModelService.getById(productModelId);
        TechnologyBomStructure root = new TechnologyBomStructure();
        root.setBomId(bomId);
        root.setParentId(null);
        root.setProductModelId(productModelId);
        root.setUnit(productModel.getUnit());
        root.setUnitQuantity(BigDecimal.ONE);
        technologyBomStructureService.save(root);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R uploadBom(MultipartFile file) {
@@ -185,157 +174,135 @@
            return R.fail("Excel解析失败");
        }

        if (list == null || list.isEmpty()) return R.fail("数据为空");
        if (list == null || list.isEmpty()) {
            return R.fail("数据为空");
        }

        //  处理工序
        list.forEach(dto -> {
            dto.setParentName(clean(dto.getParentName()));
            dto.setParentSpec(clean(dto.getParentSpec()));
            dto.setChildName(clean(dto.getChildName()));
            dto.setChildSpec(clean(dto.getChildSpec()));
            dto.setProductName(clean(dto.getProductName()));
            dto.setProductSpec(clean(dto.getProductSpec()));
            dto.setMaterialName(clean(dto.getMaterialName()));
            dto.setMaterialSpec(clean(dto.getMaterialSpec()));
            dto.setProcess(clean(dto.getProcess()));
        });
        handleProcess(list);
//        Map<String, Long> processMap = productProcessService.list().stream()
//                .collect(Collectors.toMap(ProductProcess::getName, ProductProcess::getId, (k1, k2) -> k1));

        //  创建 BOM 数据
        boolean templateMatched = list.stream().anyMatch(dto -> StringUtils.isNotBlank(dto.getProductName())
                && StringUtils.isNotBlank(dto.getMaterialName()));
        if (!templateMatched) {
            return R.fail("BOM导入模板已更新为扁平结构，请使用最新模板（成品产品名称/规格、物料产品名称/规格、消耗工序）");
        }

        BomImportDto first = list.get(0);
        ProductModel rootModel = findModel(first.getParentName(), first.getParentSpec());
        ProductModel productModel = findModel(first.getProductName(), first.getProductSpec());
        TechnologyBom bom = new TechnologyBom();
        bom.setProductModelId(rootModel.getId());
        bom.setProductModelId(productModel.getId());
        bom.setVersion("1.0");
        bom.setRemark(first.getRemark());
        technologyBomMapper.insert(bom);
        bom.setBomNo("BM." + String.format("%05d", bom.getId()));
        technologyBomMapper.updateById(bom);

        // 记录已经插入结构的节点：Key = "名称+规格", Value = structure_id
        Map<String, Long> treePathMap = new HashMap<>();
        Map<String, Long> operationIdByName = new HashMap<>();
        for (TechnologyOperation operation : technologyOperationMapper.selectList(null)) {
            if (StringUtils.isNotBlank(operation.getName())) {
                operationIdByName.putIfAbsent(operation.getName().trim(), operation.getId());
            }
        }

        Set<String> relationKeys = new HashSet<>();
        for (int i = 0; i < list.size(); i++) {
            BomImportDto dto = list.get(i);
            String parentKey = dto.getParentName() + "|" + dto.getParentSpec();
            String childKey = dto.getChildName() + "|" + dto.getChildSpec();

            //处理根节点,第一行且子项为空
            if (i == 0 && StringUtils.isBlank(dto.getChildName())) {
                TechnologyBomStructure rootNode = new TechnologyBomStructure();
                rootNode.setBomId(bom.getId().longValue());
                rootNode.setParentId(null); // 顶层没有父节点
                rootNode.setProductModelId(rootModel.getId());
                rootNode.setUnitQuantity(BigDecimal.ONE);
                rootNode.setUnit(rootModel.getUnit());
                technologyBomStructureService.save(rootNode);

                treePathMap.put(parentKey, rootNode.getId());
                continue;
            int rowNo = i + 2;
            if (StringUtils.isBlank(dto.getMaterialName())) {
                throw new ServiceException("导入失败：第" + rowNo + "行缺少物料产品名称");
            }
            if (StringUtils.isNotBlank(dto.getProductName())
                    && !sameModel(dto, first)) {
                throw new ServiceException("导入失败：第" + rowNo + "行的成品与第一行不一致，一次导入只能维护一个BOM");
            }
            if (StringUtils.isBlank(dto.getProcess())) {
                throw new ServiceException("导入失败：第" + rowNo + "行缺少消耗工序");
            }
            Long operationId = operationIdByName.get(dto.getProcess());
            if (operationId == null) {
                throw new ServiceException("导入失败：工序未维护[" + dto.getProcess() + "]（第" + rowNo + "行）");
            }

            //  处理子层级节点
            //  找到父节点在数据库里的 ID
            Long parentStructureId = treePathMap.get(parentKey);
            if (parentStructureId == null) {
                // 如果 Map 里找不到，说明 Excel 顺序乱了或者数据有误
                throw new ServiceException("导入失败: 父项[" + dto.getParentName() + "]必须在其子项之前定义");
            ProductModel materialModel = findModel(dto.getMaterialName(), dto.getMaterialSpec());
            if (materialModel.getId().equals(productModel.getId())) {
                throw new ServiceException("导入失败：第" + rowNo + "行成品规格不能作为自身的物料");
            }
            if (!relationKeys.add(materialModel.getId() + "#" + operationId)) {
                throw new ServiceException("导入失败：第" + rowNo + "行物料与工序重复配置");
            }

            //  获取子项模型信息
            ProductModel childModel = findModel(dto.getChildName(), dto.getChildSpec());

            //  插入结构表
            TechnologyBomStructure node = new TechnologyBomStructure();
            node.setBomId(bom.getId().longValue());
            node.setParentId(parentStructureId); // 父节点ID
            node.setProductModelId(childModel.getId());
            node.setUnitQuantity(dto.getUnitQty());
            node.setUnit(childModel.getUnit());
//            if (processMap.containsKey(dto.getProcess())) {
//                node.setProcessId(processMap.get(dto.getProcess()));
//            }
            node.setProductModelId(materialModel.getId());
            node.setOperationId(operationId);
            technologyBomStructureService.save(node);

            //  把当前子项记录到 Map,作为以后更深层级的父项查找依据
            //  同一父项下的同名子项不需要重复记录
            treePathMap.put(childKey, node.getId());
        }

        return R.ok("BOM导入成功");
    }


    /**
     * 导出扁平BOM：成品 + 物料 + 消耗工序。
     */
    @Override
    public void exportBom(HttpServletResponse response, Integer bomId) {
    public void exportBom(HttpServletResponse response, Long bomId) {
        if (bomId == null) {
            throw new ServiceException("BOM ID不能为空");
        }
        TechnologyBom bom = technologyBomMapper.selectById(bomId);
        if (bom == null) {
            throw new ServiceException("BOM不存在");
        }

        List<TechnologyBomStructureVo> detailList = technologyBomStructureService.listByBomId(bomId);
        if (detailList == null || detailList.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());
//                }
//            }
//        }
        ProductModel productModel = productModelService.getById(bom.getProductModelId());
        String productName = null;
        if (productModel != null && productModel.getProductId() != null) {
            Product product = productService.getById(productModel.getProductId());
            productName = product == null ? null : product.getProductName();
        }

        List<BomImportDto> exportList = new ArrayList<>(detailList.size());
        for (TechnologyBomStructureVo detail : detailList) {
            BomImportDto row = new BomImportDto();
            row.setProductName(productName);
            row.setProductSpec(productModel == null ? null : productModel.getModel());
            row.setProductCode(productModel == null ? null : productModel.getProductCode());
            row.setMaterialName(detail.getProductName());
            row.setMaterialSpec(detail.getModel());
            row.setMaterialCode(detail.getProductCode());
            row.setProcess(detail.getOperationName());
            exportList.add(row);
        }

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

    /**
     * 复制BOM：复制成品规格与全部扁平物料-工序关系。
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R copy(TechnologyBom technologyBom) {
        if (technologyBom == null || technologyBom.getId() == null) {
            throw new ServiceException("BOM ID不能为空");
        }
        TechnologyBom oldTechnologyBom = technologyBomMapper.selectById(technologyBom.getId());
        List<TechnologyBomStructureVo> oldTechnologyBomStructureVos = technologyBomStructureService.listByBomId(technologyBom.getId().longValue());
        //校验产品规格是否存在。
        if (oldTechnologyBom == null) {
            throw new ServiceException("BOM不存在");
        }
        validateProductModel(oldTechnologyBom.getProductModelId());

        TechnologyBom newTechnologyBom = new TechnologyBom();
        newTechnologyBom.setProductModelId(oldTechnologyBom.getProductModelId());
        newTechnologyBom.setVersion("FZ" + oldTechnologyBom.getVersion());
@@ -346,14 +313,30 @@
        }
        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);

        List<TechnologyBomStructureVo> oldDetailList =
                technologyBomStructureService.listByBomId(technologyBom.getId().longValue());
        if (oldDetailList != null && !oldDetailList.isEmpty()) {
            List<TechnologyBomStructure> newDetailList = new ArrayList<>(oldDetailList.size());
            for (TechnologyBomStructureVo oldDetail : oldDetailList) {
                TechnologyBomStructure newDetail = new TechnologyBomStructure();
                newDetail.setBomId(newTechnologyBom.getId().longValue());
                newDetail.setProductModelId(oldDetail.getProductModelId());
                newDetail.setOperationId(oldDetail.getOperationId());
                newDetailList.add(newDetail);
            }
            technologyBomStructureService.saveBatch(newDetailList);
        }
        return R.ok();
    }

    private boolean sameModel(BomImportDto row, BomImportDto first) {
        return StringUtils.equals(row.getProductName(), first.getProductName())
                && StringUtils.equals(defaultBlank(row.getProductSpec()), defaultBlank(first.getProductSpec()));
    }

    private String defaultBlank(String value) {
        return value == null ? "" : value;
    }

    private ProductModel findModel(String name, String spec) {
@@ -368,118 +351,8 @@
        return model;
    }

    private void handleProcess(List<BomImportDto> list) {

        Set<String> processNames = list.stream()
                .map(BomImportDto::getProcess)
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toSet());

        if (processNames.isEmpty()) {
            return;
        }

//        List<ProductProcess> exists = productProcessService.list(
//                new LambdaQueryWrapper<ProductProcess>().in(ProductProcess::getName, processNames)
//        );

//        Set<String> existNames = exists.stream()
//                .map(ProductProcess::getName)
//                .collect(Collectors.toSet());
//
//        List<ProductProcess> needSave = processNames.stream()
//                .filter(n -> !existNames.contains(n))
//                .map(n -> {
//                    ProductProcess p = new ProductProcess();
//                    p.setName(n);
//                    return p;
//                })
//                .collect(Collectors.toList());
//
//        if (!needSave.isEmpty()) {
//            productProcessService.saveBatch(needSave);
//            needSave.forEach(p -> p.setNo("GX" + String.format("%08d", p.getId())));
//            productProcessService.updateBatchById(needSave);
//        }
    }

    private String clean(String s) {
        if (s == null) return null;
        return s.replaceAll("[\\u00A0\\u3000]", "").trim();
    }

    private void populateMap(List<ProductStructureDto> nodes, Map<Long, ProductStructureDto> map) {
        if (nodes == null || nodes.isEmpty()) {
            return;
        }
        for (ProductStructureDto 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);
    }
}