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 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;
|
}
|
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));
|
}
|
|
}
|
