1.原辅料下单 2.检验对象选择

liding

2025-04-08 54f3f9d6c99f6890c39ff05b1e251a555709341a

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

@@ -6,7 +6,6 @@
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.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.basic.dto.*;
@@ -16,6 +15,7 @@
import com.ruoyi.basic.pojo.*;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.basic.service.*;
import com.ruoyi.common.utils.StringUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
@@ -81,21 +81,21 @@
            basicTreeDto.setValue(String.valueOf(model.getId()));
            basicTreeDto.setLabel(model.getModelName());
            basicTreeDto.setChildren(null);
            if(model.getProductId() != null) {
                if(CollectionUtils.isEmpty(productModelMap.get(model.getProductId()))){
            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.put(model.getProductId(), basicTreeDtoList);
                } else {
                    productModelMap.get(model.getProductId()).add(basicTreeDto);
                }
            }
            if(model.getStructureTestObjectId() != null) {
                if(CollectionUtils.isEmpty(productModelMap.get(model.getStructureTestObjectId()))){
            if (model.getStructureTestObjectId() != null) {
                if (CollectionUtils.isEmpty(testObjectModelMap.get(model.getStructureTestObjectId()))) {
                    List<BasicTreeDto> basicTreeDtoList = new ArrayList<>();
                    basicTreeDtoList.add(basicTreeDto);
                    testObjectModelMap.put(model.getStructureTestObjectId(),basicTreeDtoList);
                }else {
                    testObjectModelMap.put(model.getStructureTestObjectId(), basicTreeDtoList);
                } else {
                    testObjectModelMap.get(model.getStructureTestObjectId()).add(basicTreeDto);
                }
            }
@@ -122,15 +122,15 @@
                                    StructureTestObjectDto structureTestObjectDto = new StructureTestObjectDto();
                                    BeanUtils.copyProperties(structureTestObject, structureTestObjectDto);
                                    List<BasicTreeDto> children = new ArrayList<>();
                                    if(!CollectionUtils.isEmpty(productMap.get(structureTestObject.getId()))){
                                    if (!CollectionUtils.isEmpty(productMap.get(structureTestObject.getId()))) {
                                        children.addAll(productMap.get(structureTestObject.getId()));
                                    }
                                    if(!CollectionUtils.isEmpty(testObjectModelMap.get(structureTestObject.getId()))){
                                    if (!CollectionUtils.isEmpty(testObjectModelMap.get(structureTestObject.getId()))) {
                                        children.addAll(testObjectModelMap.get(structureTestObject.getId()));
                                    }
                                    structureTestObjectDto.setChildren(children);
                                    return structureTestObjectDto;
                                },Collectors.toList())
                                }, Collectors.toList())
                        )
                )
        );
@@ -152,13 +152,13 @@
                    BasicTreeDto objectTypeBasicTreeDto = new BasicTreeDto();
                    objectTypeBasicTreeDto.setValue(objectType);
                    objectTypeBasicTreeDto.setLevel(BasicTreeEnums.MATERIAL_TYPE.getCode());
                    objectTypeBasicTreeDto.setLabel(TestPorjectTypeEnums.getNameByCode(objectType));
                    objectTypeBasicTreeDto.setLabel(objectType);
                    List<StructureTestObjectDto> structureTestObjectTypeList = objectTypeMap.get(objectType);
                    if (CollectionUtils.isEmpty(structureTestObjectTypeList)) {
                        continue;
                    }
                    // 封装车间树
                    if (objectType.equals("1") || objectType.equals("5")) {
                    if (objectType.equals(TestPorjectTypeEnums.RAW_MATERIALS.getName()) || objectType.equals(TestPorjectTypeEnums.PACKAGING_MATERIALS.getName())) {
                        List<BasicTreeDto> workShopTreeDtoList = new ArrayList<>();
                        for (WorkShop workShop : workShopList) {
                            BasicTreeDto workShopTreeDto = new BasicTreeDto();
@@ -178,14 +178,14 @@
                                }
                            }
                            workShopTreeDto.setChildren(testObjectChildren);
                            if(!CollectionUtils.isEmpty(testObjectChildren)){
                            if (!CollectionUtils.isEmpty(testObjectChildren)) {
                                workShopTreeDtoList.add(workShopTreeDto);
                            }
                        }
                        objectTypeBasicTreeDto.setChildren(workShopTreeDtoList);
                    }
                    // 封装检测对象树
                    if (objectType.equals("2") || objectType.equals("3") || objectType.equals("4")) {
                    if (objectType.equals(TestPorjectTypeEnums.FINISHED_PRODUCT.getName()) || objectType.equals(TestPorjectTypeEnums.SEMI_FINISHED_PRODUCT.getName()) || objectType.equals(TestPorjectTypeEnums.PURCHASED_PART.getName())) {
                        objectTypeBasicTreeDto.setChildren(structureTestObjectTypeList.stream().map(structureTestObjectDto -> {
                            BasicTreeDto testObjectBasicTreeDto = new BasicTreeDto(BasicTreeEnums.STRUCTURE_TEST_OBJECT_TYPE.getCode(),
                                    structureTestObjectDto.getSpecimenName(),
@@ -201,51 +201,115 @@
            return laboratoryTreeDto;
        }).collect(Collectors.toList());
        List<BasicTreeDto> factoryList = new ArrayList<>();
        factoryList.add(new BasicTreeDto(BasicTreeEnums.FACTORY_TYPE.getCode(),"中天科技","1",laboratoryTreeDtoList));
        return laboratoryTreeDtoList;
        factoryList.add(new BasicTreeDto(BasicTreeEnums.FACTORY_TYPE.getCode(), "中天科技", "1", laboratoryTreeDtoList));
        return factoryList;
    }


    @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())
                .eq(StandardTree::getSampleType, standardTree.getSampleType())
                .eq(StandardTree::getSample, standardTree.getSample())
                .eq(StandardTree::getModel, standardTree.getModel());
        if (StringUtils.isNotBlank(standardTree.getSample())) {
            wrapper.eq(StandardTree::getSample, standardTree.getSample());
    public int addStandardTree(ModelAddDto modelAddDto) {
        // 校验
        if (StringUtils.isEmpty(modelAddDto.getParentId())) {
            throw new RuntimeException("缺少父层级绑定关系");
        }

        StandardTree tree = standardTreeMapper.selectOne(wrapper);
        if (tree != null) {
            throw new BaseException("该型号已存在");
        Model model = new Model();
        String parentLevel = modelAddDto.getParentLevel();
        // 名称重复性性校验
        QueryWrapper<Model> modelQueryWrapper = new QueryWrapper<>();
        if (BasicTreeEnums.PRODUCT_TYPE.getCode().equals(parentLevel)) {
            model.setProductId(Integer.valueOf(modelAddDto.getParentId()));
            modelQueryWrapper.eq("product_id", model.getProductId());
        } else if (BasicTreeEnums.STRUCTURE_TEST_OBJECT_TYPE.getCode().equals(parentLevel)) {
            model.setStructureTestObjectId(Integer.valueOf(modelAddDto.getParentId()));
            modelQueryWrapper.eq("structure_test_object_id", model.getStructureTestObjectId());
        } else {
            throw new RuntimeException("型号只能绑定对象和产品");
        }
        return standardTreeMapper.insert(standardTree);
        model.setModelName(modelAddDto.getModelName());
        modelQueryWrapper.eq("model_name", model.getModelName());
        Model modelResult = modelMapper.selectOne(modelQueryWrapper);

        if (ObjectUtils.isNotEmpty(modelResult)) {
            throw new RuntimeException("请勿添加重复型号");
        }
        return modelMapper.insert(model);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int delStandardTree(String tree) {
        String[] trees = tree.split(" - ");
        switch (trees.length) {
            case 5:
                if (trees[3].equals("null")) {
                    standardTreeMapper.delete(Wrappers.<StandardTree>lambdaUpdate().eq(StandardTree::getFactory, trees[0]).eq(StandardTree::getLaboratory, trees[1]).eq(StandardTree::getSampleType, trees[2]).isNull(StandardTree::getSample).eq(StandardTree::getModel, trees[4]));
                } else {
                    standardTreeMapper.delete(Wrappers.<StandardTree>lambdaUpdate().eq(StandardTree::getFactory, trees[0]).eq(StandardTree::getLaboratory, trees[1]).eq(StandardTree::getSampleType, trees[2]).eq(StandardTree::getSample, trees[3]).eq(StandardTree::getModel, trees[4]));
                }
                break;
    public int delStandardTree(String level, String id) {
        if (BasicTreeEnums.MODEL_TYPE.getCode().equals(level)) {
            modelMapper.deleteById(id);
        }
        return 1;
    }

    @Override
    public List<SampleTypeDto> getStandardTree2() {
        return standardTreeMapper.getStandardTree2();
    public List<BasicTreeDto> getStandardTree2() {
        // 查询所有检查对象
        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(model.getModelName());
            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(testObjectModelMap.get(model.getStructureTestObjectId()))) {
                    List<BasicTreeDto> basicTreeDtoList = new ArrayList<>();
                    basicTreeDtoList.add(basicTreeDto);
                    testObjectModelMap.put(model.getStructureTestObjectId(), basicTreeDtoList);
                } else {
                    testObjectModelMap.get(model.getStructureTestObjectId()).add(basicTreeDto);
                }
            }
        }
        // 按照检测对象id将产品分组并组装成BasicTreeDto
        Map<Integer, List<BasicTreeDto>> productMap = productList.stream().collect(Collectors.groupingBy(
                Product::getObjectId,
                Collectors.mapping(product -> {
                    BasicTreeDto basicTreeDto = new BasicTreeDto();
                    basicTreeDto.setValue(product.getName());
                    basicTreeDto.setLabel(product.getName());
                    basicTreeDto.setLevel(BasicTreeEnums.PRODUCT_TYPE.getCode());
                    basicTreeDto.setChildren(productModelMap.get(product.getId()));
                    return basicTreeDto;
                }, Collectors.toList())
        ));
        // 对检测对象先按照实验室在按照检查对象类别分类
        List<BasicTreeDto> testProjectBasicTreeList = structureTestObjectList.stream().map(structureTestObject -> {
            BasicTreeDto basicTreeDto = new BasicTreeDto();
            basicTreeDto.setValue(structureTestObject.getSpecimenName());
            basicTreeDto.setLabel(structureTestObject.getSpecimenName() + "(" + structureTestObject.getObjectType() + ")");
            basicTreeDto.setLevel(BasicTreeEnums.STRUCTURE_TEST_OBJECT_TYPE.getCode());
            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()));
            }
            basicTreeDto.setChildren(children);
            return basicTreeDto;
        }).collect(Collectors.toList());
        return testProjectBasicTreeList;
    }

    @Override
@@ -275,6 +339,7 @@

    /**
     * 河口检测中心导入
     *
     * @param file
     */
    @Override
@@ -554,44 +619,40 @@

    /**
     * 修改标准数
     * @param standardTree
     *
     * @param modelAddDto
     * @return
     */
    @Override
    public int updateStandardTree(StandardTree standardTree) {
        // 修改名称匹配的标准树下的检验项目
        // 查询所有对象+名称的树

        List<StandardProductList> standardProductLists = standardProductListService.list(Wrappers.<StandardProductList>lambdaUpdate()
                .eq(StandardProductList::getSample, standardTree.getSample())
                .eq(StandardProductList::getSampleType, standardTree.getSampleType())
                .eq(StandardProductList::getModel, standardTree.getOldModel()));
        if (!CollectionUtils.isEmpty(standardProductLists)) {
            for (StandardProductList standardProductList : standardProductLists) {
                // 修改样品名称
                standardProductList.setModel(standardTree.getModel());
                // 修改树名称
                // 需要截取第四级, 避免三四级名称一样修改错误
                String[] trees = standardProductList.getTree().split(" - ");
                trees[4] = standardTree.getModel();
                List<String> list = CollUtil.newArrayList(trees);
                String newName = CollUtil.join(list, " - ");
                standardProductList.setTree(newName);
    public int updateStandardTree(ModelAddDto modelAddDto) {
        if (modelAddDto.getId() == null) {
            throw new RuntimeException("缺少型号主键");
        }
        Model model = modelMapper.selectById(modelAddDto.getId());
        if (ObjectUtils.isEmpty(model)) {
            throw new RuntimeException("型号查找失败");
        }
        QueryWrapper<Model> modelQueryWrapper = new QueryWrapper<>();
        if (model.getStructureTestObjectId() != null) {
            modelQueryWrapper.eq("structure_test_object_id", model.getStructureTestObjectId());
        }
        if (model.getProductId() != null) {
            modelQueryWrapper.eq("product_id", model.getProductId());
        }
        modelQueryWrapper.eq("model_name", modelAddDto.getModelName());
        model.setModelName(modelAddDto.getModelName());
        List<Model> modelList = modelMapper.selectList(modelQueryWrapper);
        if (CollectionUtils.isEmpty(modelList)) {
            return modelMapper.updateById(model);
        } else if (modelList.size() == 1) {
            if (!model.getId().equals(modelList.get(0).getId())) {
                throw new RuntimeException("型号名称重复");
            } else {
                return modelMapper.updateById(model);
            }
            standardProductListService.updateBatchById(standardProductLists);
        } else {
            throw new RuntimeException("型号名称重复");
        }

        // 修改标准数检验项目
        LambdaUpdateWrapper<StandardTree> wrapper = Wrappers.<StandardTree>lambdaUpdate()
                .eq(StandardTree::getFactory, standardTree.getFactory())
                .eq(StandardTree::getLaboratory, standardTree.getLaboratory())
                .eq(StandardTree::getSampleType, standardTree.getSampleType())
                .eq(StandardTree::getModel, standardTree.getOldModel())
                .set(StandardTree::getModel, standardTree.getModel());
        if (StringUtils.isNotBlank(standardTree.getSample())) {
            wrapper.eq(StandardTree::getSample, standardTree.getSample());
        }
        return standardTreeMapper.update(null, wrapper);
    }

    @Override