package com.ruoyi.basic.service.impl;
|
|
import cn.hutool.json.JSONUtil;
|
import cn.hutool.poi.excel.ExcelUtil;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
|
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.pojo.StandardMethodList;
|
import com.ruoyi.common.utils.QueryWrappers;
|
import com.ruoyi.basic.mapper.StandardMethodMapper;
|
import com.ruoyi.basic.mapper.StandardProductListMapper;
|
import com.ruoyi.basic.mapper.StructureItemParameterMapper;
|
import com.ruoyi.basic.mapper.StandardMethodIndustryMapper;
|
import com.ruoyi.basic.mapper.StandardMethodAttachmentMapper;
|
import com.ruoyi.basic.mapper.LaboratoryMapper;
|
import com.ruoyi.basic.mapper.StandardTreeMapper;
|
import com.ruoyi.basic.mapper.StandardTreeTemplateBindingMapper;
|
import com.ruoyi.basic.pojo.StandardMethod;
|
import com.ruoyi.basic.pojo.StandardMethodIndustry;
|
import com.ruoyi.basic.pojo.StandardMethodAttachment;
|
import com.ruoyi.basic.pojo.Laboratory;
|
import com.ruoyi.basic.pojo.StandardTree;
|
import com.ruoyi.basic.pojo.StandardTreeTemplateBinding;
|
import com.ruoyi.basic.pojo.StandardProductList;
|
import com.ruoyi.basic.pojo.StructureItemParameter;
|
import com.ruoyi.basic.service.StandardMethodService;
|
import com.ruoyi.basic.service.StandardProductListService;
|
import com.ruoyi.basic.service.StructureItemParameterService;
|
import com.ruoyi.basic.utils.StandardTreePath;
|
import com.ruoyi.basic.utils.StandardTreePathParser;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.multipart.MultipartFile;
|
import com.ruoyi.common.exception.base.BaseException;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.concurrent.CompletableFuture;
|
|
/**
|
* @author Administrator
|
* @description 针对表【standard_method(标准方法)】的数据库操作Service实现
|
* @createDate 2024-03-03 19:21:41
|
*/
|
@Service
|
public class StandardMethodServiceImpl extends ServiceImpl<StandardMethodMapper, StandardMethod>
|
implements StandardMethodService {
|
|
|
private StandardMethodMapper standardMethodMapper;
|
|
private StandardProductListMapper standardProductListMapper;
|
private StandardProductListService standardProductListService;
|
|
private StructureItemParameterMapper structureItemParameterMapper;
|
private StructureItemParameterService structureItemParameterService;
|
|
private StandardMethodIndustryMapper standardMethodIndustryMapper;
|
private StandardMethodAttachmentMapper standardMethodAttachmentMapper;
|
private LaboratoryMapper laboratoryMapper;
|
private StandardTreeMapper standardTreeMapper;
|
private StandardTreeTemplateBindingMapper standardTreeTemplateBindingMapper;
|
|
@Value("${file.path}")
|
private String filePath;
|
|
@Value("${wordUrl}")
|
private String wordUrl;
|
|
/**
|
* 业务依赖由构造器注入；文件路径由 @Value 从配置读取，不能参与 Lombok 的全参构造器，
|
* 否则 Spring 会把 String 误认为需要注入的 Bean。
|
*/
|
public StandardMethodServiceImpl(StandardMethodMapper standardMethodMapper,
|
StandardProductListMapper standardProductListMapper,
|
StandardProductListService standardProductListService,
|
StructureItemParameterMapper structureItemParameterMapper,
|
StructureItemParameterService structureItemParameterService,
|
StandardMethodIndustryMapper standardMethodIndustryMapper,
|
StandardMethodAttachmentMapper standardMethodAttachmentMapper,
|
LaboratoryMapper laboratoryMapper,
|
StandardTreeMapper standardTreeMapper,
|
StandardTreeTemplateBindingMapper standardTreeTemplateBindingMapper) {
|
this.standardMethodMapper = standardMethodMapper;
|
this.standardProductListMapper = standardProductListMapper;
|
this.standardProductListService = standardProductListService;
|
this.structureItemParameterMapper = structureItemParameterMapper;
|
this.structureItemParameterService = structureItemParameterService;
|
this.standardMethodIndustryMapper = standardMethodIndustryMapper;
|
this.standardMethodAttachmentMapper = standardMethodAttachmentMapper;
|
this.laboratoryMapper = laboratoryMapper;
|
this.standardTreeMapper = standardTreeMapper;
|
this.standardTreeTemplateBindingMapper = standardTreeTemplateBindingMapper;
|
}
|
|
@Override
|
public IPage<StandardMethod> selectStandardMethodList(Page page, StandardMethod standardMethod) {
|
IPage<StandardMethod> result = standardMethodMapper.selectStandardMethodList(page, QueryWrappers.queryWrappers(standardMethod));
|
for (StandardMethod method : result.getRecords()) {
|
method.setIndustryIds(selectIndustryIds(method.getId()));
|
}
|
return result;
|
}
|
|
@Override
|
public List<StandardMethod> selectStandardMethods() {
|
return standardMethodMapper.selectList(Wrappers.<StandardMethod>lambdaQuery().select(StandardMethod::getId, StandardMethod::getCode, StandardMethod::getName).ne(StandardMethod::getId, 0));
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public Integer addStandardMethod(StandardMethod standardMethod) {
|
standardMethod.setStructureTestObjectId(null);
|
standardMethodMapper.insert(standardMethod);
|
syncIndustries(standardMethod, Collections.<Integer>emptySet());
|
return standardMethod.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int delStandardMethod(Integer id) {
|
StandardMethod method = standardMethodMapper.selectById(id);
|
if (method == null) {
|
throw new BaseException("标准不存在");
|
}
|
for (Integer industryId : selectIndustryIds(id)) {
|
removeIndustryTree(method, industryId);
|
}
|
standardMethodIndustryMapper.delete(Wrappers.<StandardMethodIndustry>lambdaQuery()
|
.eq(StandardMethodIndustry::getStandardMethodId, id));
|
standardMethodAttachmentMapper.delete(Wrappers.<StandardMethodAttachment>lambdaQuery()
|
.eq(StandardMethodAttachment::getStandardMethodId, id));
|
return standardMethodMapper.deleteById(id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public int upStandardMethod(StandardMethod standardMethod) {
|
StandardMethod oldStandardMethod = standardMethodMapper.selectById(standardMethod.getId());
|
if (oldStandardMethod == null) {
|
throw new BaseException("标准不存在");
|
}
|
if (!oldStandardMethod.getCode().equals(standardMethod.getCode())) {
|
CompletableFuture.supplyAsync(() -> replaceMethod(oldStandardMethod.getCode(), standardMethod.getCode()));
|
}
|
int i = standardMethodMapper.updateById(standardMethod);
|
syncIndustries(standardMethod, new LinkedHashSet<>(selectIndustryIds(oldStandardMethod.getId())));
|
return i;
|
}
|
|
private List<Integer> selectIndustryIds(Integer methodId) {
|
List<StandardMethodIndustry> list = standardMethodIndustryMapper.selectList(
|
Wrappers.<StandardMethodIndustry>lambdaQuery()
|
.eq(StandardMethodIndustry::getStandardMethodId, methodId));
|
List<Integer> ids = new ArrayList<>();
|
for (StandardMethodIndustry item : list) {
|
ids.add(item.getIndustryId());
|
}
|
return ids;
|
}
|
|
private void syncIndustries(StandardMethod method, Set<Integer> oldIds) {
|
Set<Integer> newIds = method.getIndustryIds() == null ? new LinkedHashSet<Integer>()
|
: new LinkedHashSet<>(method.getIndustryIds());
|
for (Integer industryId : newIds) {
|
if (industryId == null || laboratoryMapper.selectById(industryId) == null) {
|
throw new BaseException("行业不存在");
|
}
|
}
|
for (Integer oldId : oldIds) {
|
if (!newIds.contains(oldId)) {
|
removeIndustryTree(method, oldId);
|
standardMethodIndustryMapper.delete(Wrappers.<StandardMethodIndustry>lambdaQuery()
|
.eq(StandardMethodIndustry::getStandardMethodId, method.getId())
|
.eq(StandardMethodIndustry::getIndustryId, oldId));
|
}
|
}
|
for (Integer industryId : newIds) {
|
Laboratory lab = laboratoryMapper.selectById(industryId);
|
Long count = standardMethodIndustryMapper.selectCount(Wrappers.<StandardMethodIndustry>lambdaQuery()
|
.eq(StandardMethodIndustry::getStandardMethodId, method.getId())
|
.eq(StandardMethodIndustry::getIndustryId, industryId));
|
if (count == 0) {
|
StandardMethodIndustry relation = new StandardMethodIndustry();
|
relation.setStandardMethodId(method.getId());
|
relation.setIndustryId(industryId);
|
standardMethodIndustryMapper.insert(relation);
|
}
|
StandardTree tree = standardTreeMapper.selectOne(Wrappers.<StandardTree>lambdaQuery()
|
.eq(StandardTree::getLaboratory, lab.getLaboratoryName())
|
.eq(StandardTree::getStandardMethodId, method.getId())
|
.isNull(StandardTree::getSampleType).isNull(StandardTree::getModel));
|
if (tree == null) {
|
tree = new StandardTree();
|
tree.setLaboratory(lab.getLaboratoryName());
|
tree.setSample(buildLabel(method));
|
tree.setStandardMethodId(method.getId());
|
tree.setSort(0);
|
standardTreeMapper.insert(tree);
|
} else if (!buildLabel(method).equals(tree.getSample())) {
|
StandardTree update = new StandardTree();
|
update.setId(tree.getId());
|
update.setSample(buildLabel(method));
|
standardTreeMapper.updateById(update);
|
}
|
}
|
}
|
|
private void removeIndustryTree(StandardMethod method, Integer industryId) {
|
Laboratory lab = laboratoryMapper.selectById(industryId);
|
if (lab == null) return;
|
StandardTree tree = standardTreeMapper.selectOne(Wrappers.<StandardTree>lambdaQuery()
|
.eq(StandardTree::getLaboratory, lab.getLaboratoryName())
|
.eq(StandardTree::getStandardMethodId, method.getId())
|
.isNull(StandardTree::getSampleType).isNull(StandardTree::getModel));
|
if (tree != null) {
|
standardTreeTemplateBindingMapper.delete(Wrappers.<StandardTreeTemplateBinding>lambdaQuery()
|
.eq(StandardTreeTemplateBinding::getStandardTreeId, tree.getId()));
|
standardProductListMapper.delete(Wrappers.<StandardProductList>lambdaQuery()
|
.eq(StandardProductList::getLaboratory, lab.getLaboratoryName())
|
.eq(StandardProductList::getSample, tree.getSample())
|
.isNull(StandardProductList::getSampleType).isNull(StandardProductList::getModel));
|
standardTreeMapper.deleteById(tree.getId());
|
}
|
}
|
|
private String buildLabel(StandardMethod method) {
|
return method.getCode().trim();
|
}
|
|
@Override
|
public List<StandardMethodAttachment> selectAttachments(Integer standardMethodId) {
|
return standardMethodAttachmentMapper.selectList(Wrappers.<StandardMethodAttachment>lambdaQuery()
|
.eq(StandardMethodAttachment::getStandardMethodId, standardMethodId)
|
.orderByAsc(StandardMethodAttachment::getSort, StandardMethodAttachment::getId));
|
}
|
|
@Override
|
public StandardMethodAttachment uploadAttachment(Integer standardMethodId, MultipartFile file) {
|
if (standardMethodMapper.selectById(standardMethodId) == null) throw new BaseException("标准不存在");
|
if (file == null || file.isEmpty() || file.getSize() > 10 * 1024 * 1024)
|
throw new BaseException("附件不能为空且不能超过10MB");
|
String originalName = file.getOriginalFilename();
|
if (originalName == null || !originalName.matches("(?i).+\\.(jpg|jpeg|png|gif|doc|docx|xls|xlsx|ppt|pptx|pdf|zip|rar)$"))
|
throw new BaseException("不支持的附件格式");
|
try {
|
boolean image = originalName.matches("(?i).+\\.(jpg|jpeg|png|gif)$");
|
File directory = new File(image ? filePath : wordUrl);
|
if (!directory.exists()) directory.mkdirs();
|
String fileUrl = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyMMddHHmmssSSS")) + "-" + originalName;
|
file.transferTo(new File(directory, fileUrl));
|
StandardMethodAttachment attachment = new StandardMethodAttachment();
|
attachment.setStandardMethodId(standardMethodId);
|
attachment.setFileName(originalName);
|
attachment.setFileUrl(fileUrl);
|
attachment.setSort(selectAttachments(standardMethodId).size());
|
standardMethodAttachmentMapper.insert(attachment);
|
return attachment;
|
} catch (IOException e) {
|
throw new BaseException("附件上传失败");
|
}
|
}
|
|
@Override
|
public boolean deleteAttachment(Long id) {
|
return standardMethodAttachmentMapper.deleteById(id) > 0;
|
}
|
|
@Override
|
public List<Laboratory> selectIndustryOptions() {
|
return laboratoryMapper.selectList(Wrappers.<Laboratory>lambdaQuery()
|
.select(Laboratory::getId, Laboratory::getLaboratoryName, Laboratory::getSort)
|
.orderByAsc(Laboratory::getSort, Laboratory::getId));
|
}
|
|
//编辑method后全部替换
|
public String replaceMethod(String oldCode, String code) {
|
//查询StandardProductList中所有Method如果包含之前的则替换
|
List<StandardProductList> standardProductLists = standardProductListMapper.selectList(null);
|
for (StandardProductList standardProductList : standardProductLists) {
|
if (standardProductList.getMethod().contains(oldCode)) {
|
String[] split = standardProductList.getMethod().split(",");
|
String a = null;
|
for (int i = 0; i < split.length; i++) {
|
String methodName = split[i].substring(1, split[i].length() - 1);
|
if (i == 0) {
|
methodName = split[i].substring(2, split[i].length() - 1);
|
} else if (i == split.length - 1) {
|
methodName = split[i].substring(1, split[i].length() - 2);
|
}
|
if (methodName.equals(oldCode)) {
|
methodName = code;
|
}
|
a += "\"" + methodName + "\",";
|
}
|
String method = "[\"" + a.substring(0, a.length() - 1) + "\"]";
|
standardProductList.setMethod(method);
|
}
|
}
|
standardProductListService.updateBatchById(standardProductLists);
|
//查询StructureItemParameter中所有Method如果包含之前的则替换
|
List<StructureItemParameter> structureItemParameters = structureItemParameterMapper.selectList(null);
|
for (StructureItemParameter structureItemParameter : structureItemParameters) {
|
if (structureItemParameter.getMethod().contains(oldCode)) {
|
String[] split = structureItemParameter.getMethod().split(",");
|
String a = null;
|
for (int i = 0; i < split.length; i++) {
|
String methodName = split[i].substring(1, split[i].length() - 1);
|
if (i == 0) {
|
methodName = split[i].substring(2, split[i].length() - 1);
|
} else if (i == split.length - 1) {
|
methodName = split[i].substring(1, split[i].length() - 2);
|
}
|
if (methodName.equals(oldCode)) {
|
methodName = code;
|
}
|
a += "\"" + methodName + "\",";
|
}
|
String method = "[\"" + a.substring(0, a.length() - 1) + "\"]";
|
structureItemParameter.setMethod(method);
|
}
|
}
|
structureItemParameterService.updateBatchById(structureItemParameters);
|
return "替换完毕!";
|
}
|
|
|
// 格式化数据
|
public StandardMethod formatData(List<Object> list) {
|
StandardMethod standardMethod = new StandardMethod();
|
standardMethod.setField(list.get(1).toString());
|
// 造格式
|
List<List<Object>> structureTestObjectId = new ArrayList<>();
|
if (ObjectUtils.isEmpty(list.get(3))) {
|
structureTestObjectId.add(Arrays.asList(list.get(2)));
|
} else {
|
structureTestObjectId.add(Arrays.asList(list.get(2), list.get(3)));
|
}
|
standardMethod.setStructureTestObjectId(JSONUtil.toJsonStr(structureTestObjectId));
|
standardMethod.setCode(list.get(4).toString());
|
standardMethod.setName(list.get(5).toString());
|
standardMethod.setNameEn(list.get(6).toString());
|
if (!Objects.equals(list.get(7), null)) {
|
standardMethod.setRemark(list.get(7).toString());
|
}
|
standardMethod.setQualificationId(list.get(8).toString());
|
if (ObjectUtils.isNotEmpty(list.get(9))) {
|
if (list.get(9).equals("是")) {
|
standardMethod.setIsProduct(1);
|
} else if (list.get(9).equals("否")) {
|
standardMethod.setIsProduct(0);
|
}
|
}
|
if (ObjectUtils.isNotEmpty(list.get(10))) {
|
if (list.get(10).equals("是")) {
|
standardMethod.setIsUse(1);
|
} else if (list.get(9).equals("否")) {
|
standardMethod.setIsUse(0);
|
}
|
}
|
return standardMethod;
|
}
|
|
@Override
|
public Map<String, List<?>> selectsStandardMethodByFLSSM(String tree) {
|
if (tree == null || tree.trim().isEmpty()) {
|
return Collections.emptyMap();
|
}
|
StandardTreePath path = StandardTreePathParser.parse(tree);
|
String industry = path.getIndustry();
|
List<StandardMethodList> standardMethodLists = new ArrayList<>(standardMethodMapper.selectStandardMethodListsByIndustry(industry));
|
// 按 ID 去重，保持稳定排序
|
Map<Integer, StandardMethodList> byId = new LinkedHashMap<>();
|
for (StandardMethodList m : standardMethodLists) {
|
byId.putIfAbsent(m.getId(), m);
|
}
|
Map<String, List<?>> map = new HashMap<>();
|
map.put("standardMethodList", new ArrayList<>(byId.values()));
|
return map;
|
}
|
|
@Override
|
public List<StandardMethodList> selectStandardMethodEnum() {
|
return standardMethodMapper.selectListEnum();
|
}
|
|
}
|
