package com.ruoyi.basic.service.impl;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
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.PageTestObjectDto;
|
import com.ruoyi.basic.dto.TestItemDto;
|
import com.ruoyi.basic.mapper.*;
|
import com.ruoyi.basic.pojo.*;
|
import com.ruoyi.basic.service.CapacityScopeService;
|
import com.ruoyi.common.core.domain.entity.SysDictData;
|
import com.ruoyi.common.exception.base.BaseException;
|
import com.ruoyi.common.utils.QueryWrappers;
|
import com.ruoyi.basic.service.StandardProductListService;
|
import com.ruoyi.basic.service.StructureItemParameterService;
|
import com.ruoyi.system.mapper.SysDictTypeMapper;
|
import com.ruoyi.system.service.ISysDictTypeService;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.Arrays;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Objects;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.stream.Collectors;
|
|
/**
|
* 检验项目参数(StructureItemParameter)表服务实现类
|
*
|
* @author makejava
|
* @since 2024-02-26 16:21:17
|
*/
|
@Service
|
@AllArgsConstructor
|
public class CapacityScopeServiceImpl extends ServiceImpl<StructureItemParameterMapper, StructureItemParameter> implements CapacityScopeService {
|
|
private StandardProductListMapper standardProductListMapper;
|
|
private ThreadPoolTaskExecutor threadPoolTaskExecutor;
|
|
private StructureItemParameterMapper structureItemParameterMapper;
|
|
private StructureTestObjectMapper structureTestObjectMapper;
|
|
private ProductMapper productMapper;
|
|
private StandardProductListService standardProductListService;
|
|
private StandardTreeMapper standardTreeMapper;
|
|
private StructureItemParameterService structureItemParameterService;
|
|
private ISysDictTypeService sysDictTypeService;
|
|
@Override
|
public IPage<StructureItemParameter> selectItemParameterList(Page page, StructureItemParameter itemParameter) {
|
IPage<StructureItemParameter> parameterIPage = structureItemParameterMapper.selectItemParameterList(page, QueryWrappers.queryWrappers(itemParameter));
|
//查询字典
|
Map<String, List<SysDictData>> dictMaps = sysDictTypeService.selectEnumListByCategory(Arrays.asList("检验项类型", "是否", "检验值类型", "单位"));
|
parameterIPage.getRecords().forEach(ele->{
|
ele.setInspectionItemTypeTwo(getLabelByValue(dictMaps.get("检验项类型"),ele.getInspectionItemType()));
|
ele.setUpdateBsm(getLabelByValue(dictMaps.get("是否"),ele.getBsm()));
|
ele.setInspectionValueTypeTwo(getLabelByValue(dictMaps.get("检验值类型"),ele.getInspectionValueType()));
|
});
|
return parameterIPage;
|
}
|
|
/**
|
* 根据value获取字典
|
* @param dictList
|
* @param value
|
* @return
|
*/
|
private String getLabelByValue(List<SysDictData> dictList, String value){
|
if(dictList.isEmpty()){
|
return "";
|
}
|
return dictList.stream().filter(ele-> Objects.equals(ele.getDictValue(),value)).map(SysDictData::getDictLabel).findFirst().orElse("");
|
}
|
|
@Override
|
public int addItemParameter(StructureItemParameter itemParameter) {
|
if (itemParameter.getBsm().equals("")||itemParameter.getBsm()==null){
|
itemParameter.setBsm("0");
|
}
|
int insert = structureItemParameterMapper.insert(itemParameter);
|
return insert;
|
}
|
|
@Override
|
public int delItemParameter(Integer id) {
|
return structureItemParameterMapper.deleteById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int upItemParameter(StructureItemParameter itemParameter) {
|
//能力范围更新，同时更新对应的标准库
|
StructureItemParameter oldParameter = structureItemParameterMapper.selectById(itemParameter.getId());
|
//判断检验项、检验子项、单位是否有修改，有就同时修改标准库对应的数据
|
if(
|
!StringUtils.equals(itemParameter.getInspectionItem(),oldParameter.getInspectionItem()) ||
|
!StringUtils.equals(itemParameter.getInspectionItemSubclass(),oldParameter.getInspectionItemSubclass()) ||
|
!StringUtils.equals(itemParameter.getInspectionItemEn(),oldParameter.getInspectionItemEn()) ||
|
!StringUtils.equals(itemParameter.getInspectionItemSubclassEn(),oldParameter.getInspectionItemSubclassEn()) ||
|
!StringUtils.equals(itemParameter.getUnit(),oldParameter.getUnit())
|
){
|
CompletableFuture.runAsync(() -> {
|
LambdaUpdateWrapper<StandardProductList> updateWrapper = Wrappers.<StandardProductList>lambdaUpdate()
|
.set(StandardProductList::getInspectionItem, itemParameter.getInspectionItem())
|
.set(StandardProductList::getInspectionItemEn, itemParameter.getInspectionItemEn())
|
.set(StandardProductList::getInspectionItemSubclass, itemParameter.getInspectionItemSubclass())
|
.set(StandardProductList::getInspectionItemSubclassEn, itemParameter.getInspectionItemSubclassEn())
|
.set(StandardProductList::getUnit, itemParameter.getUnit())
|
.eq(StandardProductList::getStructureItemParameterId,itemParameter.getId());
|
standardProductListMapper.update(null,updateWrapper);
|
},threadPoolTaskExecutor);
|
}
|
return structureItemParameterMapper.updateById(itemParameter);
|
}
|
|
@Override
|
public IPage<PageTestObjectDto> selectTestObjectList(Page page, PageTestObjectDto pageTestObjectDto) {
|
return structureTestObjectMapper.selectTestObjectList(page, QueryWrappers.queryWrappers(pageTestObjectDto));
|
}
|
|
@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) {
|
List<Product> products = productMapper.selectList(Wrappers.<Product>lambdaQuery()
|
.eq(Product::getObjectId, id));
|
List<Integer> productIds = products.stream().map(Product::getId).collect(Collectors.toList());
|
// 删除产品维护
|
if (productIds.size()>0) {
|
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();
|
}
|
}
|
