package com.ruoyi.basic.service.impl;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.basic.dto.*;
|
import com.ruoyi.basic.excel.StructureTestObjectData;
|
import com.ruoyi.basic.service.*;
|
import com.ruoyi.common.exception.base.BaseException;
|
import com.ruoyi.common.utils.QueryWrappers;
|
import com.ruoyi.basic.mapper.*;
|
import com.ruoyi.basic.pojo.*;
|
import com.ruoyi.common.utils.StringUtils;
|
import lombok.AllArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
import java.util.stream.Stream;
|
|
/**
|
* 检验项目参数(StructureItemParameter)表服务实现类
|
*
|
* @author makejava
|
* @since 2024-02-26 16:21:17
|
*/
|
@Service
|
@AllArgsConstructor
|
public class CapacityScopeServiceImpl extends ServiceImpl<StructureItemParameterMapper, StructureItemParameter> implements CapacityScopeService {
|
|
private StructureItemParameterMapper structureItemParameterMapper;
|
|
private StructureTestObjectMapper structureTestObjectMapper;
|
|
private ProductMapper productMapper;
|
|
private ProductService productService;
|
|
private StructureTestObjectService structureTestObjectService;
|
|
private StructureTestObjectPartMapper structureTestObjectPartMapper;
|
|
private ProductPartMapper productPartMapper;
|
|
private StandardProductListService standardProductListService;
|
|
private StandardTreeMapper standardTreeMapper;
|
|
private StructureItemParameterService structureItemParameterService;
|
|
private WorkShopMapper workShopMapper;
|
|
private ModelMapper modelMapper;
|
|
@Override
|
public IPage<StructureItemParameter> selectItemParameterList(Page page, StructureItemParameter itemParameter) {
|
return structureItemParameterMapper.selectItemParameterList(page, QueryWrappers.queryWrappers(itemParameter));
|
}
|
|
@Override
|
public int addItemParameter(StructureItemParameter itemParameter) {
|
if (itemParameter.getBsm().equals("") || itemParameter.getBsm() == null) {
|
itemParameter.setBsm("0");
|
}
|
return structureItemParameterMapper.insert(itemParameter);
|
}
|
|
@Override
|
public int delItemParameter(Integer id) {
|
return structureItemParameterMapper.deleteById(id);
|
}
|
|
@Override
|
public int upItemParameter(StructureItemParameter itemParameter) {
|
return structureItemParameterMapper.updateById(itemParameter);
|
}
|
|
@Override
|
public IPage<PageTestObjectDto> selectTestObjectList(Page page, PageTestObjectDto pageTestObjectDto) {
|
String specimenName = pageTestObjectDto.getSample();
|
pageTestObjectDto.setSample(null);
|
return structureTestObjectMapper.selectTestObjectList(page, QueryWrappers.queryWrappers(pageTestObjectDto), specimenName);
|
}
|
|
@Override
|
public int addTestObject(StructureTestObject testObject) {
|
Long count = structureTestObjectMapper.selectCount(Wrappers.<StructureTestObject>lambdaQuery().eq(StructureTestObject::getSpecimenName, testObject.getSpecimenName()));
|
if (count.compareTo(0L) > 0) {
|
throw new BaseException("检验对象不能重复");
|
}
|
|
return structureTestObjectMapper.insert(testObject);
|
}
|
|
@Override
|
public int delTestObject(Integer id) {
|
// 产出检验对象产品维护
|
structureTestObjectPartMapper.delete(Wrappers.<StructureTestObjectPart>lambdaQuery()
|
.eq(StructureTestObjectPart::getTestObjectId, id));
|
|
// 删除产品维护的零件绑定
|
List<Product> products = productMapper.selectList(Wrappers.<Product>lambdaQuery()
|
.eq(Product::getObjectId, id));
|
List<Integer> productIds = products.stream().map(Product::getId).collect(Collectors.toList());
|
if (CollectionUtils.isNotEmpty(productIds)) {
|
productPartMapper.delete(Wrappers.<ProductPart>lambdaQuery()
|
.in(ProductPart::getProductId, productIds));
|
|
// 删除产品维护
|
productMapper.delete(Wrappers.<Product>lambdaQuery()
|
.in(Product::getId, productIds));
|
}
|
|
return structureTestObjectMapper.deleteById(id);
|
}
|
|
@Override
|
public int upTestObject(StructureTestObject testObject) {
|
// 查询旧的检验对象
|
StructureTestObject oldTestObject = structureTestObjectMapper.selectById(testObject.getId());
|
|
if (!oldTestObject.getSpecimenName().equals(testObject.getSpecimenName())) {
|
// 查询所有对象一样的检验项目
|
List<StandardProductList> standardProductLists = standardProductListService.list(Wrappers.<StandardProductList>lambdaUpdate()
|
.eq(StandardProductList::getSampleType, oldTestObject.getSpecimenName()));
|
if (CollectionUtils.isNotEmpty(standardProductLists)) {
|
for (StandardProductList standardProductList : standardProductLists) {
|
// 修改所有的对象名称和数型结构
|
standardProductList.setSampleType(testObject.getSpecimenName());
|
// 需要截取第三级, 避免三四级名称一样修改错误
|
String[] trees = standardProductList.getTree().split(" - ");
|
trees[2] = testObject.getSpecimenName();
|
List<String> list = CollUtil.newArrayList(trees);
|
String newName = CollUtil.join(list, " - ");
|
standardProductList.setTree(newName);
|
}
|
standardProductListService.updateBatchById(standardProductLists);
|
}
|
// 修改检验项目参数的检验对象
|
// 拼接 ["object", 查询检验项目参数修改绑定的检验对象
|
String format = "[\"{}\",";
|
String sampleOld = StrUtil.format(format, oldTestObject.getSpecimenName());
|
List<StructureItemParameter> itemParameterList = structureItemParameterService.list(Wrappers.<StructureItemParameter>lambdaQuery()
|
.like(StructureItemParameter::getSample, sampleOld));
|
if (CollectionUtils.isNotEmpty(itemParameterList)) {
|
for (StructureItemParameter structureItemParameter : itemParameterList) {
|
// 修改绑定的样品名称
|
String sampleNew = StrUtil.format(format, testObject.getSpecimenName());
|
String sampleUp = structureItemParameter.getSample().replace(sampleOld, sampleNew);
|
structureItemParameter.setSample(sampleUp);
|
}
|
structureItemParameterService.updateBatchById(itemParameterList);
|
}
|
|
// 修改树的型号
|
standardTreeMapper.update(null, Wrappers.<StandardTree>lambdaUpdate()
|
.eq(StandardTree::getSampleType, oldTestObject.getSpecimenName())
|
.set(StandardTree::getSampleType, testObject.getSpecimenName()));
|
}
|
|
Long count = structureTestObjectMapper.selectCount(Wrappers.<StructureTestObject>lambdaQuery()
|
.eq(StructureTestObject::getSpecimenName, testObject.getSpecimenName())
|
.ne(StructureTestObject::getId, testObject.getId()));
|
if (count.compareTo(0L) > 0) {
|
throw new BaseException("检验对象不能重复");
|
}
|
|
return structureTestObjectMapper.updateById(testObject);
|
}
|
|
@Override
|
public List<StructureTestObject> selectTestObjectByName() {
|
return structureTestObjectMapper.selectList(Wrappers.<StructureTestObject>lambdaQuery().select(StructureTestObject::getSpecimenName, StructureTestObject::getId));
|
}
|
|
//设备里面选择检验项目(树形结构)
|
@Override
|
public List<Map<String, Object>> getInsProduction() {
|
return structureItemParameterMapper.getInsProduction();
|
}
|
|
@Override
|
public List<TestItemDto> getItemTree() {
|
return structureItemParameterMapper.getItemTree();
|
}
|
|
@Override
|
public List<TestItemDto> getItemTreeProduct(StructureTestObjectDto structureTestObjectDto) {
|
return structureItemParameterMapper.getItemTreeProduct(structureTestObjectDto.getObjectType());
|
}
|
|
@Override
|
public List<Model> getProductTypes(ModelDto modelDto) {
|
return modelMapper.selectList(Wrappers.<Model>lambdaQuery().eq(Model::getProductId,modelDto.getProductId()));
|
}
|
|
@Override
|
public List<ProductPart> getPartNoList(ProductPartDto productPartDto) {
|
return productPartMapper.selectList(Wrappers.<ProductPart>lambdaQuery().eq(ProductPart::getProductId,productPartDto.getProductId()));
|
}
|
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public void importPartExcel(List<StructureTestObjectData> list) {
|
// 阶段2: 批量查询现有结构测试对象
|
Map<String, StructureTestObject> existStructureTestObjects = structureTestObjectMapper.selectList(
|
Wrappers.<StructureTestObject>lambdaQuery()
|
.in(StructureTestObject::getSpecimenName, list.stream().map(StructureTestObjectData::getSpecimenName).collect(Collectors.toSet()))
|
.in(StructureTestObject::getSpecimenNameEn, list.stream().map(StructureTestObjectData::getSpecimenNameEn).collect(Collectors.toSet()))
|
.in(StructureTestObject::getObjectType, list.stream().map(StructureTestObjectData::getObjectType).collect(Collectors.toSet()))
|
).stream().collect(Collectors.toMap(
|
obj -> generateStructureKey(obj.getSpecimenName(), obj.getSpecimenNameEn(), obj.getObjectType()), // 统一键生成
|
Function.identity(),
|
(existing, replacement) -> existing
|
));
|
|
// 阶段3: 预处理车间信息
|
Set<String> workShopNames = list.stream()
|
.map(StructureTestObjectData::getWorkShopName)
|
.filter(StringUtils::isNotEmpty)
|
.collect(Collectors.toSet());
|
|
Map<String, WorkShop> workShopCache = workShopNames.isEmpty() ?
|
Collections.emptyMap() :
|
workShopMapper.selectList(Wrappers.<WorkShop>lambdaQuery()
|
.in(WorkShop::getName, workShopNames))
|
.stream()
|
.collect(Collectors.toMap(WorkShop::getName, Function.identity()));
|
|
// 阶段4: 准备批量操作数据
|
List<StructureTestObject> structureTestObjectsToInsert = new ArrayList<>();
|
List<StructureTestObject> structureTestObjectsToUpdate = new ArrayList<>();
|
List<Product> productsToInsert = new ArrayList<>();
|
List<Product> productsToUpdate = new ArrayList<>();
|
|
// 阶段5: 主处理逻辑（仅处理结构测试对象）
|
List<StructureTestObjectData> pendingProducts = new ArrayList<>(); // 新增：暂存待处理的产品数据
|
|
for (StructureTestObjectData i : list) {
|
// 处理结构测试对象（逻辑不变）
|
String specimenKey = i.getSpecimenName() + "|" + i.getSpecimenNameEn() + "|" + i.getObjectType();
|
StructureTestObject structureTestObject = existStructureTestObjects.get(specimenKey);
|
|
if (structureTestObject == null) {
|
StructureTestObject newObj = createNewStructureTestObject(i, workShopCache); // 修改：传入车间缓存
|
structureTestObjectsToInsert.add(newObj);
|
existStructureTestObjects.put(specimenKey, newObj);
|
} else {
|
updateExistingStructureTestObject(structureTestObject, i);
|
structureTestObjectsToUpdate.add(structureTestObject);
|
}
|
|
// 暂存产品处理数据（新增）
|
pendingProducts.add(i);
|
}
|
|
// 阶段6: 先处理结构测试对象批量操作
|
executeStructureTestObjectBatch(structureTestObjectsToInsert, structureTestObjectsToUpdate);
|
|
// 阶段7: 更新缓存中的ID（关键新增步骤）
|
refreshStructureTestObjectIds(existStructureTestObjects, structureTestObjectsToInsert);
|
|
// 阶段8: 处理产品数据
|
processProducts(pendingProducts, existStructureTestObjects, workShopCache,
|
productsToInsert, productsToUpdate);
|
|
// 阶段9: 执行产品批量操作
|
executeProductBatch(productsToInsert, productsToUpdate);
|
}
|
|
// 更新现有结构测试对象
|
private void updateExistingStructureTestObject(StructureTestObject obj, StructureTestObjectData data) {
|
obj.setCode(data.getCode());
|
obj.setLaboratoryId(9);
|
}
|
|
// 统一键生成方法
|
private String generateStructureKey(String name, String nameEn, String objectType) {
|
return name + "|" + nameEn + "|" + objectType;
|
}
|
|
// 处理产品数据
|
private void processProductData(StructureTestObjectData data,
|
Integer objectId,
|
Map<String, WorkShop> workShopCache,
|
List<Product> insertList,
|
List<Product> updateList) {
|
// 构建产品唯一标识
|
String productKey = data.getName() + "|" + data.getNameEn() + "|" + data.getObjectType();
|
|
// 检查内存中是否已处理过该产品
|
Optional<Product> existingProduct = findProductInBatchLists(productKey, insertList, updateList);
|
|
// 如果内存中不存在，查询数据库
|
if (!existingProduct.isPresent()) {
|
Product dbProduct = productMapper.selectOne(Wrappers.<Product>lambdaQuery()
|
.eq(Product::getName, data.getName())
|
.eq(Product::getNameEn, data.getNameEn())
|
.last("limit 1"));
|
existingProduct = Optional.ofNullable(dbProduct);
|
}
|
|
// 创建或更新产品
|
Product product = existingProduct.orElseGet(Product::new);
|
boolean isNew = product.getId() == null;
|
|
// 设置产品属性
|
setupProduct(product, data, objectId, workShopCache);
|
|
// 加入对应列表
|
if (isNew) {
|
insertList.add(product);
|
} else {
|
updateList.add(product);
|
}
|
}
|
|
// 在产品批量列表中查找
|
private Optional<Product> findProductInBatchLists(String productKey,
|
List<Product> insertList,
|
List<Product> updateList) {
|
return Stream.concat(insertList.stream(), updateList.stream())
|
.filter(p -> (p.getName() + "|" + p.getNameEn()).equals(productKey))
|
.findFirst();
|
}
|
|
// 设置产品信息
|
private void setupProduct(Product product,
|
StructureTestObjectData data,
|
Integer objectId,
|
Map<String, WorkShop> workShopCache) {
|
product.setName(data.getName());
|
product.setNameEn(data.getNameEn());
|
product.setObjectId(objectId);
|
// 处理车间信息
|
if (StringUtils.isNotEmpty(data.getWorkShopName())) {
|
WorkShop workShop = workShopCache.get(data.getWorkShopName());
|
if (workShop == null) {
|
throw new BaseException("车间信息未维护: " + data.getWorkShopName());
|
}
|
product.setWorkShopId(workShop.getId());
|
product.setWorkShopName(data.getWorkShopName());
|
}
|
}
|
|
// 创建结构测试对象（使用缓存车间信息）
|
private StructureTestObject createNewStructureTestObject(StructureTestObjectData data,
|
Map<String, WorkShop> workShopCache) {
|
StructureTestObject obj = new StructureTestObject();
|
obj.setLaboratoryId(9);
|
obj.setSpecimenName(data.getSpecimenName());
|
obj.setSpecimenNameEn(data.getSpecimenNameEn());
|
obj.setCode(data.getCode());
|
obj.setObjectType(data.getObjectType());
|
|
// 使用缓存获取车间信息
|
if (StringUtils.isNotEmpty(data.getWorkShopName())) {
|
WorkShop workShop = workShopCache.get(data.getWorkShopName());
|
if (workShop == null) {
|
throw new BaseException("车间信息未维护: " + data.getWorkShopName());
|
}
|
obj.setWorkShopId(workShop.getId());
|
obj.setWorkShopName(data.getWorkShopName());
|
} else {
|
obj.setWorkShopName("");
|
}
|
return obj;
|
}
|
|
// 刷新结构测试对象ID（关键方法）
|
private void refreshStructureTestObjectIds(
|
Map<String, StructureTestObject> existStructureTestObjects,
|
List<StructureTestObject> insertedObjects) {
|
|
insertedObjects.forEach(obj -> {
|
String key = obj.getSpecimenName() + "|" + obj.getSpecimenNameEn()+ "|" + obj.getObjectType();
|
existStructureTestObjects.get(key).setId(obj.getId()); // 更新缓存中的ID
|
});
|
}
|
|
// 处理产品数据（独立方法）
|
private void processProducts(List<StructureTestObjectData> pendingProducts,
|
Map<String, StructureTestObject> structureTestObjectCache,
|
Map<String, WorkShop> workShopCache,
|
List<Product> insertList,
|
List<Product> updateList) {
|
|
// 阶段5原有产品处理逻辑迁移至此
|
pendingProducts.forEach(i -> {
|
String specimenKey = i.getSpecimenName() + "|" + i.getSpecimenNameEn()+ "|" + i.getObjectType();
|
StructureTestObject sto = structureTestObjectCache.get(specimenKey);
|
|
processProductData(
|
i,
|
sto.getId(), // 此时ID已正确设置
|
workShopCache,
|
insertList,
|
updateList
|
);
|
});
|
}
|
|
// 分拆批量操作方法
|
private void executeStructureTestObjectBatch(List<StructureTestObject> toInsert,
|
List<StructureTestObject> toUpdate) {
|
if (!toInsert.isEmpty()) {
|
structureTestObjectMapper.insertBatchSomeColumn(toInsert);
|
}
|
if (!toUpdate.isEmpty()) {
|
structureTestObjectService.updateBatchById(toUpdate);
|
}
|
}
|
|
private void executeProductBatch(List<Product> toInsert,
|
List<Product> toUpdate) {
|
if (!toInsert.isEmpty()) {
|
productMapper.insertBatchSomeColumn(toInsert);
|
}
|
if (!toUpdate.isEmpty()) {
|
productService.updateBatchById(toUpdate);
|
}
|
}
|
|
}
|
