标准库树查询修改

chenrui

2025-03-25 4ac4b1505f60088e59d78d999205377a8f170ca2

标准库树查询修改

 basic-server/src/main/java/com/ruoyi/basic/dto/BasicTreeDto.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,29 @@
package com.ruoyi.basic.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import java.util.List;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString(exclude = {"children"})
public class BasicTreeDto {

    /**
     * å±‚级
     */
    private String level;

    private String label;

    private String value;

    /**
     * å­èŠ‚点
     */
    private List<BasicTreeDto> children;
}

 basic-server/src/main/java/com/ruoyi/basic/dto/StructureTestObjectDto.java

@@ -1,15 +1,18 @@
package com.ruoyi.basic.dto;

import com.ruoyi.basic.pojo.StructureTestObject;
import lombok.Data;

@Data
public class StructureTestObjectDto {
import java.util.List;

    private Integer id;
@Data
public class StructureTestObjectDto extends StructureTestObject {

    private String name;

    private Integer workShopId;

    private String workShopName;

    private List<BasicTreeDto> children;
}

 basic-server/src/main/java/com/ruoyi/basic/enums/BasicTreeEnums.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,37 @@
package com.ruoyi.basic.enums;

public enum BasicTreeEnums {

    FACTORY_TYPE("1","公司"),
    LABORATORY_TYPE("2","实验室"),
    MATERIAL_TYPE("3","材料"),
    WORK_SHOP_TYPE("4","车间"),
    STRUCTURE_TEST_OBJECT_TYPE("5","检验对象"),
    PRODUCT_TYPE("6","产品"),
    MODEL_TYPE("7","型号");

    private String code;

    private String name;

    BasicTreeEnums(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

 basic-server/src/main/java/com/ruoyi/basic/enums/TestPorjectTypeEnums.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package com.ruoyi.basic.enums;

public enum TestPorjectTypeEnums {

    RAW_MATERIALS("1","原辅料"),
    FINISHED_PRODUCT("2","成品"),
    SEMI_FINISHED_PRODUCT("3","半成品"),
    PURCHASED_PART("4","外购件"),
    PACKAGING_MATERIALS("5","包材");

    private String code;

    private String name;

    TestPorjectTypeEnums(String code, String name) {
        this.code = code;
        this.name = name;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static String getNameByCode(String code) {
        for (TestPorjectTypeEnums type : TestPorjectTypeEnums.values()) {
            if (type.getCode().equals(code)) {
                return type.getName();
            }
        }
        return "";
    }
}

 basic-server/src/main/java/com/ruoyi/basic/mapper/ModelMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,7 @@
package com.ruoyi.basic.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ruoyi.basic.pojo.Model;

public interface ModelMapper extends BaseMapper<Model> {
}

 basic-server/src/main/java/com/ruoyi/basic/pojo/Model.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,42 @@
package com.ruoyi.basic.pojo;

import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.time.LocalDateTime;

@TableName(value = "model")
@Data
public class Model {

    @ApiModelProperty(value = "主键")
    @TableId(type = IdType.AUTO)
    private Integer id;

    @ApiModelProperty(value = "型号名称")
    private String modelName;

    @ApiModelProperty(value = "产品ID")
    private Integer productId;

    @ApiModelProperty(value = "检验对象ID")
    private Integer structureTestObjectId;

    @ApiModelProperty(value = "创建人")
    @TableField(fill = FieldFill.INSERT)
    private Integer createUser;

    @ApiModelProperty(value = "修改人id")
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Integer updateUser;

    @TableField(fill = FieldFill.INSERT_UPDATE)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime updateTime;

    @TableField(fill = FieldFill.INSERT)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createTime;
}

 basic-server/src/main/java/com/ruoyi/basic/service/StandardTreeService.java

@@ -1,6 +1,7 @@
package com.ruoyi.basic.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.basic.dto.BasicTreeDto;
import com.ruoyi.basic.dto.FactoryDto;
import com.ruoyi.basic.dto.SampleTypeDto;
import com.ruoyi.basic.pojo.StandardTree;
@@ -16,7 +17,7 @@
*/
public interface StandardTreeService extends IService<StandardTree> {

    List<FactoryDto> selectStandardTreeList();
    List<BasicTreeDto> selectStandardTreeList();


    int addStandardTree(StandardTree standardTree);

 basic-server/src/main/java/com/ruoyi/basic/service/impl/StandardTreeServiceImpl.java

@@ -3,29 +3,25 @@
import cn.hutool.core.collection.CollUtil;
import cn.hutool.poi.excel.ExcelUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.dto.SampleDto;
import com.ruoyi.basic.dto.*;
import com.ruoyi.basic.enums.BasicTreeEnums;
import com.ruoyi.basic.enums.TestPorjectTypeEnums;
import com.ruoyi.basic.mapper.*;
import com.ruoyi.basic.pojo.*;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.basic.dto.FactoryDto;
import com.ruoyi.basic.dto.LaboratoryDto;
import com.ruoyi.basic.dto.SampleTypeDto;
import com.ruoyi.basic.mapper.StandardProductListMapper;
import com.ruoyi.basic.mapper.StandardTreeMapper;
import com.ruoyi.basic.pojo.StandardProductList;
import com.ruoyi.basic.pojo.StandardTemplate;
import com.ruoyi.basic.pojo.StandardTree;
import com.ruoyi.basic.pojo.StructureTestObject;
import com.ruoyi.basic.service.*;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
@@ -57,42 +53,163 @@

    private StructureTestObjectService structureTestObjectService;

    private StructureTestObjectMapper structureTestObjectMapper;

    private ProductMapper productMapper;

    private ModelMapper modelMapper;

    private LaboratoryMapper laboratoryMapper;

    private WorkShopMapper workShopMapper;


    @Override
    public List<FactoryDto> selectStandardTreeList() {
        List<FactoryDto> factoryDtos = standardTreeMapper.selectStandardTreeList();
        // æ”¶é›†æ‰€æœ‰ sampleTypeDto çš„ value
        Set<String> sampleTypeValues = new HashSet<>();
        for (FactoryDto factoryDto : factoryDtos) {
            for (LaboratoryDto laboratoryDto : factoryDto.getChildren()) {
                laboratoryDto.getChildren().sort((o1, o2) -> (o1.getSort() == null ? 0 : o1.getSort())
                        - (o2.getSort() == null ? 0 : o2.getSort()));
                for (SampleTypeDto sampleTypeDto : laboratoryDto.getChildren()) {
                    sampleTypeValues.add(sampleTypeDto.getValue());
    public List<BasicTreeDto> selectStandardTreeList() {
        // æŸ¥è¯¢æ‰€æœ‰æ£€æŸ¥å¯¹è±¡
        List<StructureTestObject> structureTestObjectList = structureTestObjectMapper.selectList(new QueryWrapper<StructureTestObject>());
        // æŸ¥è¯¢æ‰€æœ‰äº§å“
        List<Product> productList = productMapper.selectList(new LambdaQueryWrapper<Product>());
        // æŸ¥è¯¢æ‰€æœ‰åž‹å·
        List<Model> modelList = modelMapper.selectList(new QueryWrapper<Model>());
        // æŒ‰ç…§å½’属产品id还是归属检测对象id将型号分组并组装成BasicTreeDto
        Map<Integer, List<BasicTreeDto>> productModelMap = new HashMap<>();
        Map<Integer, List<BasicTreeDto>> testObjectModelMap = new HashMap<>();
        for (Model model : modelList) {
            BasicTreeDto basicTreeDto = new BasicTreeDto();
            basicTreeDto.setLevel(BasicTreeEnums.MODEL_TYPE.getCode());
            basicTreeDto.setValue(String.valueOf(model.getId()));
            basicTreeDto.setLabel(model.getModelName());
            basicTreeDto.setChildren(null);
            if(model.getProductId() != null) {
                if(CollectionUtils.isEmpty(productModelMap.get(model.getProductId()))){
                    List<BasicTreeDto> basicTreeDtoList = new ArrayList<>();
                    basicTreeDtoList.add(basicTreeDto);
                    productModelMap.put(model.getProductId(),basicTreeDtoList);
                }else {
                    productModelMap.get(model.getProductId()).add(basicTreeDto);
                }
            }
            if(model.getStructureTestObjectId() != null) {
                if(CollectionUtils.isEmpty(productModelMap.get(model.getStructureTestObjectId()))){
                    List<BasicTreeDto> basicTreeDtoList = new ArrayList<>();
                    basicTreeDtoList.add(basicTreeDto);
                    testObjectModelMap.put(model.getStructureTestObjectId(),basicTreeDtoList);
                }else {
                    testObjectModelMap.get(model.getStructureTestObjectId()).add(basicTreeDto);
                }
            }
        }
        // æ‰¹é‡æŸ¥è¯¢æ‰€æœ‰ sampleTypeDto çš„数据
        List<SampleDto> standardList = standardTreeMapper.getStandardTree3Batch(sampleTypeValues);
        Map<String, List<SampleDto>> standardTreeMap = standardList.stream().collect(Collectors.groupingBy(SampleDto::getValue));
        // å°†æŸ¥è¯¢ç»“果分配到对应的 sampleTypeDto
        for (FactoryDto factoryDto : factoryDtos) {
            for (LaboratoryDto laboratoryDto : factoryDto.getChildren()) {
                for (SampleTypeDto sampleTypeDto : laboratoryDto.getChildren()) {
                    List<SampleDto> standardTreeList = standardTreeMap.get(sampleTypeDto.getValue());
                    if (standardTreeList != null) {
                        sampleTypeDto.getChildren().addAll(standardTreeList);
        // æŒ‰ç…§æ£€æµ‹å¯¹è±¡id将产品分组并组装成BasicTreeDto
        Map<Integer, List<BasicTreeDto>> productMap = productList.stream().collect(Collectors.groupingBy(
                Product::getObjectId,
                Collectors.mapping(product -> {
                    BasicTreeDto basicTreeDto = new BasicTreeDto();
                    basicTreeDto.setValue(String.valueOf(product.getId()));
                    basicTreeDto.setLabel(product.getName());
                    basicTreeDto.setLevel(BasicTreeEnums.PRODUCT_TYPE.getCode());
                    basicTreeDto.setChildren(productModelMap.get(product.getId()));
                    return basicTreeDto;
                }, Collectors.toList())
        ));
        // å¯¹æ£€æµ‹å¯¹è±¡å…ˆæŒ‰ç…§å®žéªŒå®¤åœ¨æŒ‰ç…§æ£€æŸ¥å¯¹è±¡ç±»åˆ«åˆ†ç±»
        Map<Integer, Map<String, List<StructureTestObjectDto>>> laboratoryObjectTypeMap = structureTestObjectList.stream().collect(
                Collectors.groupingBy(
                        StructureTestObject::getLaboratoryId,
                        Collectors.groupingBy(
                                StructureTestObject::getObjectType,
                                Collectors.mapping(structureTestObject -> {
                                    StructureTestObjectDto structureTestObjectDto = new StructureTestObjectDto();
                                    BeanUtils.copyProperties(structureTestObject, structureTestObjectDto);
                                    List<BasicTreeDto> children = new ArrayList<>();
                                    if(!CollectionUtils.isEmpty(productMap.get(structureTestObject.getId()))){
                                        children.addAll(productMap.get(structureTestObject.getId()));
                                    }
                                    if(!CollectionUtils.isEmpty(testObjectModelMap.get(structureTestObject.getId()))){
                                        children.addAll(testObjectModelMap.get(structureTestObject.getId()));
                                    }
                                    structureTestObjectDto.setChildren(children);
                                    return structureTestObjectDto;
                                },Collectors.toList())
                        )
                )
        );
        // æŸ¥è¯¢è½¦é—´
        List<WorkShop> workShopList = workShopMapper.selectList(new LambdaQueryWrapper<WorkShop>());
        // æŸ¥è¯¢å®žéªŒå®¤
        List<Laboratory> laboratoryList = laboratoryMapper.selectList(new QueryWrapper<Laboratory>());
        // å°è£…实验室树
        List<BasicTreeDto> laboratoryTreeDtoList = laboratoryList.stream().map(laboratory -> {
            BasicTreeDto laboratoryTreeDto = new BasicTreeDto();
            laboratoryTreeDto.setValue(String.valueOf(laboratory.getId()));
            laboratoryTreeDto.setLevel(BasicTreeEnums.LABORATORY_TYPE.getCode());
            laboratoryTreeDto.setLabel(laboratory.getLaboratoryName());
            // å°è£…检测对象材料类型树
            List<BasicTreeDto> objectTypeChildren = new ArrayList<>();
            Map<String, List<StructureTestObjectDto>> objectTypeMap = laboratoryObjectTypeMap.get(laboratory.getId());
            if (!CollectionUtils.isEmpty(objectTypeMap)) {
                for (String objectType : objectTypeMap.keySet()) {
                    BasicTreeDto objectTypeBasicTreeDto = new BasicTreeDto();
                    objectTypeBasicTreeDto.setValue(objectType);
                    objectTypeBasicTreeDto.setLevel(BasicTreeEnums.MATERIAL_TYPE.getCode());
                    objectTypeBasicTreeDto.setLabel(TestPorjectTypeEnums.getNameByCode(objectType));
                    List<StructureTestObjectDto> structureTestObjectTypeList = objectTypeMap.get(objectType);
                    if (CollectionUtils.isEmpty(structureTestObjectTypeList)) {
                        continue;
                    }
                    // å°è£…车间树
                    if (objectType.equals("1") || objectType.equals("5")) {
                        List<BasicTreeDto> workShopTreeDtoList = new ArrayList<>();
                        for (WorkShop workShop : workShopList) {
                            BasicTreeDto workShopTreeDto = new BasicTreeDto();
                            workShopTreeDto.setLevel(BasicTreeEnums.WORK_SHOP_TYPE.getCode());
                            workShopTreeDto.setValue(String.valueOf(workShop.getId()));
                            workShopTreeDto.setLabel(workShop.getName());
                            List<BasicTreeDto> testObjectChildren = new ArrayList<>();
                            // å°è£…检测对象树
                            for (StructureTestObjectDto structureTestObjectDto : structureTestObjectTypeList) {
                                if (workShop.getId().equals(structureTestObjectDto.getWorkShopId())) {
                                    BasicTreeDto testObjectTreeDto = new BasicTreeDto();
                                    testObjectTreeDto.setLevel(BasicTreeEnums.STRUCTURE_TEST_OBJECT_TYPE.getCode());
                                    testObjectTreeDto.setValue(String.valueOf(structureTestObjectDto.getId()));
                                    testObjectTreeDto.setLabel(structureTestObjectDto.getSpecimenName());
                                    testObjectTreeDto.setChildren(structureTestObjectDto.getChildren());
                                    testObjectChildren.add(testObjectTreeDto);
                                }
                            }
                            workShopTreeDto.setChildren(testObjectChildren);
                            if(!CollectionUtils.isEmpty(testObjectChildren)){
                                workShopTreeDtoList.add(workShopTreeDto);
                            }
                        }
                        objectTypeBasicTreeDto.setChildren(workShopTreeDtoList);
                    }
                    // å°è£…检测对象树
                    if (objectType.equals("2") || objectType.equals("3") || objectType.equals("4")) {
                        objectTypeBasicTreeDto.setChildren(structureTestObjectTypeList.stream().map(structureTestObjectDto -> {
                            BasicTreeDto testObjectBasicTreeDto = new BasicTreeDto(BasicTreeEnums.STRUCTURE_TEST_OBJECT_TYPE.getCode(),
                                    structureTestObjectDto.getSpecimenName(),
                                    String.valueOf(structureTestObjectDto.getId()),
                                    structureTestObjectDto.getChildren());
                            return testObjectBasicTreeDto;
                        }).collect(Collectors.toList()));
                    }
                    objectTypeChildren.add(objectTypeBasicTreeDto);
                }
            }
        }
        return factoryDtos;
            laboratoryTreeDto.setChildren(objectTypeChildren);
            return laboratoryTreeDto;
        }).collect(Collectors.toList());
        List<BasicTreeDto> factoryList = new ArrayList<>();
        factoryList.add(new BasicTreeDto(BasicTreeEnums.FACTORY_TYPE.getCode(),"中天科技","1",laboratoryTreeDtoList));
        return laboratoryTreeDtoList;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addStandardTree(StandardTree standardTree) {

        LambdaQueryWrapper<StandardTree> wrapper = Wrappers.<StandardTree>lambdaQuery()
                .eq(StandardTree::getFactory, standardTree.getFactory())
                .eq(StandardTree::getLaboratory, standardTree.getLaboratory())
@@ -449,7 +566,7 @@
                .eq(StandardProductList::getSample, standardTree.getSample())
                .eq(StandardProductList::getSampleType, standardTree.getSampleType())
                .eq(StandardProductList::getModel, standardTree.getOldModel()));
        if (CollectionUtils.isNotEmpty(standardProductLists)) {
        if (!CollectionUtils.isEmpty(standardProductLists)) {
            for (StandardProductList standardProductList : standardProductLists) {
                // ä¿®æ”¹æ ·å“åç§°
                standardProductList.setModel(standardTree.getModel());