package com.ruoyi.basic.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.poi.excel.ExcelUtil;
import com.alibaba.fastjson.JSON;
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.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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.service.*;
import com.ruoyi.common.utils.StringUtils;
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;
import java.io.InputStream;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * @author Administrator
 * @description 针对表【standard_tree(标准树)】的数据库操作Service实现
 * @createDate 2024-03-01 15:06:44
 */
@Service
@AllArgsConstructor
public class StandardTreeServiceImpl extends ServiceImpl<StandardTreeMapper, StandardTree>
        implements StandardTreeService {


    private StandardTreeMapper standardTreeMapper;

    private StandardMethodListService standardMethodListService;

    private StandardProductListMapper standardProductListMapper;

    private StandardProductListService standardProductListService;

    private StandardTemplateService standardTemplateService;

    private StructureTestObjectService structureTestObjectService;

    private StructureTestObjectMapper structureTestObjectMapper;

    private ProductMapper productMapper;

    private ModelMapper modelMapper;

    private LaboratoryMapper laboratoryMapper;

    private WorkShopMapper workShopMapper;


    @Override
    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(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(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(objectType);
                    List<StructureTestObjectDto> structureTestObjectTypeList = objectTypeMap.get(objectType);
                    if (CollectionUtils.isEmpty(structureTestObjectTypeList)) {
                        continue;
                    }
                    // 封装车间树
                    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();
                            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(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(),
                                    String.valueOf(structureTestObjectDto.getId()),
                                    structureTestObjectDto.getChildren());
                            return testObjectBasicTreeDto;
                        }).collect(Collectors.toList()));
                    }
                    objectTypeChildren.add(objectTypeBasicTreeDto);
                }
            }
            laboratoryTreeDto.setChildren(objectTypeChildren);
            return laboratoryTreeDto;
        }).collect(Collectors.toList());
        List<BasicTreeDto> factoryList = new ArrayList<>();
        factoryList.add(new BasicTreeDto(BasicTreeEnums.FACTORY_TYPE.getCode(),"中天科技","1",laboratoryTreeDtoList));
        return factoryList;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public int addStandardTree(ModelAddDto modelAddDto) {
        // 校验
        if(StringUtils.isEmpty(modelAddDto.getParentId())){
            throw new RuntimeException("缺少父层级绑定关系");
        }
        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("型号只能绑定对象和产品");
        }
        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 level,String id) {
        if(BasicTreeEnums.MODEL_TYPE.getCode().equals(level)){
            modelMapper.deleteById(id);
        }
        return 1;
    }

    @Override
    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());
            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
    @Transactional(rollbackFor = Exception.class)
    public int upStandardProducts(Map<String, Object> product) {
        List<Integer> ids = JSON.parseArray(product.get("ids") + "");
        StandardProductList productList = JSON.parseObject(JSON.toJSONString(product.get("standardProductList")), StandardProductList.class);
        if (productList.getMethodS() != null) {
            standardProductListMapper.update(productList, Wrappers.<StandardProductList>lambdaUpdate().in(StandardProductList::getId, ids).like(StandardProductList::getMethod, productList.getMethodS()));
            return 1;
        }
        if (productList.getRadiusList() != null) {
            standardProductListMapper.update(productList, Wrappers.<StandardProductList>lambdaUpdate().in(StandardProductList::getId, ids).like(StandardProductList::getRadiusList, productList.getRadius()));
            return 1;
        }
        standardProductListMapper.update(productList, Wrappers.<StandardProductList>lambdaUpdate().in(StandardProductList::getId, ids));
        return 1;
    }

    @Override
    public List<StandardTree> getStandTreeBySampleType(String laboratory, String sampleType) {
        return standardTreeMapper.selectList(Wrappers.<StandardTree>lambdaQuery()
                .eq(StandardTree::getLaboratory, laboratory)
                .eq(StandardTree::getSampleType, sampleType)
                .select(StandardTree::getModel, StandardTree::getSample));
    }

    /**
     * 河口检测中心导入
     * @param file
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void inExcelOfTree(MultipartFile file) {
        InputStream inputStream;
        try {
            inputStream = file.getInputStream();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<StandardProductList> lists = new ArrayList<>();
        AtomicReference<String> laboratory = new AtomicReference<>();
        ExcelUtil.readBySax(inputStream, 0, (i, l, list) -> {
            StandardProductList str = new StandardProductList();
            if (i == 0 && l == 1) {
                laboratory.set(standardTreeMapper.getLaboratory(list.get(1) + ""));
                if (laboratory.get() == null) {
                    throw new BaseException("检验对象不存在：" + list.get(1));
                }
            }
            if (i == 0 && l >= 1) {
                Integer standardMethodId = standardMethodListService.getStandardMethodId(list.get(0) + "");
                if (standardMethodId == null) {
                    throw new BaseException("标准编号不存在：" + list.get(0));
                }
                str.setStandardMethodListId(standardMethodId);
                str.setSampleType(list.get(1) + "");
                if (list.get(2) != null) {
                    String sample = baseMapper.selSample(list.get(2) + "");
                    if (sample == null) {
                        throw new BaseException("样品不存在：" + list.get(2));
                    }
                    str.setSample(list.get(2) + "");
                } else {
                    str.setSample(null);
                }
                if (list.get(3) != null) {
                    str.setModel(list.get(3) + "");
                    Long aLong = standardTreeMapper.selectCount(Wrappers.<StandardTree>lambdaQuery()
                            .eq(StandardTree::getModel, str.getModel())
                            .eq(StandardTree::getSampleType, list.get(1) + ""));
                    if (aLong == 0) {
                        StandardTree standardTree = new StandardTree();
                        standardTree.setFactory("中天科技检测中心");
                        standardTree.setLaboratory(laboratory.get());
                        standardTree.setSampleType(str.getSampleType());
                        standardTree.setSample(str.getSample());
                        standardTree.setModel(str.getModel());
                        standardTreeMapper.insert(standardTree);
                    }
                } else {
                    str.setModel(null);
                }
                str.setInspectionItem(list.get(4) + "");
                if (list.get(6) == null) {
                    str.setInspectionItemSubclass("");
                } else {
                    str.setInspectionItemSubclass(list.get(6).toString());
                }
                StandardProductList db_str;
                try {
                    db_str = standardProductListMapper.getOne(str.getStandardMethodListId(), str.getInspectionItem(), str.getSample(), str.getInspectionItemSubclass(), str.getModel(), str.getInspectionItemClass());
                } catch (Exception e) {
                    throw new BaseException("重复查询：" + str.getInspectionItem() + " " + str.getInspectionItemSubclass());
                }
                if (ObjectUtils.isNotEmpty(db_str)) {
                    str.setId(db_str.getId());
                    str.setStructureItemParameterId(db_str.getStructureItemParameterId());
                }
                if (list.get(8) != null) {
                    str.setMethodS(list.get(8) + "");
                }

                if (list.get(11) == null) {
                    str.setTell(null);
                } else {
                    str.setTell(list.get(11).toString());
                }

                if (list.get(12) == null) {
                    str.setAsk(null);
                } else {
                    str.setAsk(list.get(12).toString());
                }

                if (list.get(13) == null) {
                    str.setPrice(null);
                } else {
                    str.setPrice((list.get(13).toString()));
                }

                if (list.get(14) == null) {
                    str.setManHour(null);
                } else {
                    str.setManHour(list.get(14).toString());
                }

                StandardTemplate standTempIdByName = standardTemplateService.getStandTempIdByName(String.valueOf(list.get(21)));
                if (standTempIdByName != null) {
                    str.setTemplateId(standTempIdByName.getId());
                } else {
                    throw new BaseException("模板不存在：" + list.get(21));
                }
                str.setFactory("中天科技检测中心");
                str.setLaboratory(laboratory.get());
                str.setState(1);
                str.setTree(str.getFactory() + " - " + str.getLaboratory() + " - " + str.getSampleType() + " - " + str.getSample() + " - " + (str.getModel() == null ? "" : str.getModel()));
                try {
                    str.setStructureItemParameterId(standardTreeMapper.getStructureItemParameterId("\"" + str.getSampleType() + "\"", str.getInspectionItem(), str.getInspectionItemSubclass(), str.getInspectionItemClass()));
                } catch (Exception e) {
                    str.setStructureItemParameterId(standardTreeMapper.getStructureItemParameterId("\"" + str.getSampleType() + "\",\"" + str.getSample() + "\"", str.getInspectionItem(), str.getInspectionItemSubclass(), str.getInspectionItemClass()));
                }
                if (str.getStructureItemParameterId() == null) {
                    throw new BaseException("检验项目不存在：" + str.getInspectionItem() + " " + str.getInspectionItemSubclass());
                }
                lists.add(str);
            }
        });
        lists.forEach(a -> {
            if (a.getId() != null) {
                standardProductListMapper.updateById(a);
            } else {
                standardProductListMapper.insert(a);
            }
        });
    }

    @Override
    public void importWorkstationExcel(MultipartFile file) {
        InputStream inputStream;
        try {
            inputStream = file.getInputStream();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        List<StandardProductList> lists = new ArrayList<>();
        AtomicReference<String> laboratory = new AtomicReference<>();
        ExcelUtil.readBySax(inputStream, 0, (i, l, list) -> {
            StandardProductList str = new StandardProductList();
            if (i == 0 && l == 1) {
                laboratory.set(standardTreeMapper.getLaboratory(list.get(1) + ""));
                if (laboratory.get() == null) {
                    throw new BaseException("检验对象不存在：" + list.get(1));
                }
            }
            if (i == 0 && l >= 1) {
                Integer standardMethodId = standardMethodListService.getStandardMethodId(list.get(0) + "");
                if (standardMethodId == null) {
                    throw new BaseException("标准编号不存在：" + list.get(0));
                }
                str.setStandardMethodListId(standardMethodId);
                str.setSampleType(list.get(1) + "");
                if (list.get(2) != null) {
                    String sample = baseMapper.selSample(list.get(2) + "");
                    if (sample == null) {
                        throw new BaseException("样品不存在：" + list.get(2));
                    }
                    str.setSample(list.get(2) + "");
                } else {
                    str.setSample(null);
                }
                if (list.get(3) != null) {
                    str.setModel(list.get(3) + "");
                    Long aLong = standardTreeMapper.selectCount(Wrappers.<StandardTree>lambdaQuery()
                            .eq(StandardTree::getModel, str.getModel())
                            .eq(StandardTree::getSampleType, list.get(1) + ""));
                    if (aLong == 0) {
                        StandardTree standardTree = new StandardTree();
                        standardTree.setFactory("中天科技检测中心");
                        standardTree.setLaboratory(laboratory.get());
                        standardTree.setSampleType(str.getSampleType());
                        standardTree.setSample(str.getSample());
                        standardTree.setModel(str.getModel());
                        standardTreeMapper.insert(standardTree);
                    }
                } else {
                    str.setModel(null);
                }
                str.setInspectionItemClass(list.get(4).toString());
                str.setInspectionItemClassEn(list.get(5).toString());
                // 开始加2
                str.setInspectionItem(list.get(6) + "");
                if (list.get(8) == null) {
                    str.setInspectionItemSubclass("");
                } else {
                    str.setInspectionItemSubclass(list.get(8).toString());
                }
                StandardProductList db_str;
                try {
                    db_str = standardProductListMapper.getOne(str.getStandardMethodListId(), str.getInspectionItem(), str.getSample(), str.getInspectionItemSubclass(), str.getModel(), str.getInspectionItemClass());
                } catch (Exception e) {
                    throw new BaseException("重复查询：" + str.getInspectionItem() + " " + str.getInspectionItemSubclass());
                }
                if (ObjectUtils.isNotEmpty(db_str)) {
                    str.setId(db_str.getId());
                    str.setStructureItemParameterId(db_str.getStructureItemParameterId());
                }
                if (list.get(10) != null) {
                    str.setMethodS(list.get(10) + "");
                }
                if (list.get(13) == null) {
                    str.setTell(null);
                } else {
                    str.setTell(list.get(13).toString());
                }

                if (list.get(14) == null) {
                    str.setAsk(null);
                } else {
                    str.setAsk(list.get(14).toString());
                }

                if (list.get(15) == null) {
                    str.setPrice(null);
                } else {
                    str.setPrice((list.get(15).toString()));
                }

                if (list.get(16) == null) {
                    str.setManHour(null);
                } else {
                    str.setManHour(list.get(16).toString());
                }

                StandardTemplate standTempIdByName = standardTemplateService.getStandTempIdByName(String.valueOf(list.get(23)));
                if (standTempIdByName != null) {
                    str.setTemplateId(standTempIdByName.getId());
                } else {
                    throw new BaseException("模板不存在：" + list.get(23));
                }
                str.setFactory("中天科技检测中心");
                str.setLaboratory(laboratory.get());
                str.setState(1);
                str.setTree(str.getFactory() + " - " + str.getLaboratory() + " - " + str.getSampleType() + " - " + str.getSample() + " - " + (str.getModel() == null ? "" : str.getModel()));
                try {
                    str.setStructureItemParameterId(standardTreeMapper.getStructureItemParameterId("\"" + str.getSampleType() + "\"", str.getInspectionItem(), str.getInspectionItemSubclass(), str.getInspectionItemClass()));
                } catch (Exception e) {
                    str.setStructureItemParameterId(standardTreeMapper.getStructureItemParameterId("\"" + str.getSampleType() + "\",\"" + str.getSample() + "\"", str.getInspectionItem(), str.getInspectionItemSubclass(), str.getInspectionItemClass()));
                }
                if (str.getStructureItemParameterId() == null) {
                    throw new BaseException("检验项目不存在：" + str.getInspectionItem() + " " + str.getInspectionItemSubclass());
                }
                lists.add(str);
            }
        });
        lists.forEach(a -> {
            if (a.getId() != null) {
                standardProductListMapper.updateById(a);
            } else {
                standardProductListMapper.insert(a);
            }
        });
    }

    @Override
    public boolean updateTreeSort(List<FactoryDto> list) {
        List<StructureTestObject> testObjects = new ArrayList<>();
        for (FactoryDto factoryDto : list) {
            for (LaboratoryDto laboratoryDto : factoryDto.getChildren()) {
                List<SampleTypeDto> children = laboratoryDto.getChildren();
                int sort = 0;
                // 循环第三层
                for (SampleTypeDto child : children) {
                    StructureTestObject structureTestObject = new StructureTestObject();
                    structureTestObject.setSort(sort);
                    structureTestObject.setId(child.getSampleTypeId());
                    testObjects.add(structureTestObject);
                    sort++;
                }
            }
        }
        structureTestObjectService.updateBatchById(testObjects);

        return true;
    }

    /**
     * 修改标准数
     * @param modelAddDto
     * @return
     */
    @Override
    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);
            }
        }else {
            throw new RuntimeException("型号名称重复");
        }
    }

    @Override
    public void resetTreeOfPrice(String tree, Integer standardId) {
        standardProductListMapper.update(null, Wrappers.<StandardProductList>lambdaUpdate().like(StandardProductList::getTree, tree).eq(StandardProductList::getStandardMethodListId, standardId).set(StandardProductList::getPrice, null));
    }

    @Override
    public void resetTreeOfHour(String tree, Integer standardId) {
        standardProductListMapper.update(null, Wrappers.<StandardProductList>lambdaUpdate().like(StandardProductList::getTree, tree).eq(StandardProductList::getStandardMethodListId, standardId).set(StandardProductList::getManHour, null));
    }

    @Override
    public void resetTreeOfAsk(String tree, Integer standardId) {
        standardProductListMapper.update(null, Wrappers.<StandardProductList>lambdaUpdate().like(StandardProductList::getTree, tree).eq(StandardProductList::getStandardMethodListId, standardId)
                .set(StandardProductList::getAsk, null)
                .set(StandardProductList::getTell, null)
                .set(StandardProductList::getSection, null)
                .set(StandardProductList::getCores, null)
                .set(StandardProductList::getConductorMaterial, null)
                .set(StandardProductList::getConductorType, null)
                .set(StandardProductList::getPrice, null)
                .set(StandardProductList::getManHour, null));
    }

}