package com.chinaztt.mes.quality.service.impl;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.alibaba.druid.sql.visitor.functions.Trim;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
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.baomidou.mybatisplus.extension.toolkit.SqlHelper;
|
import com.chinaztt.mes.basic.entity.Param;
|
import com.chinaztt.mes.basic.service.ParamService;
|
import com.chinaztt.mes.basic.util.DictUtils;
|
import com.chinaztt.mes.common.numgen.NumberGenerator;
|
import com.chinaztt.mes.quality.dto.TestStandardDTO;
|
import com.chinaztt.mes.quality.entity.ReportSample;
|
import com.chinaztt.mes.quality.entity.TestStandard;
|
import com.chinaztt.mes.quality.entity.TestStandardParam;
|
import com.chinaztt.mes.quality.excel.TestStandardData;
|
import com.chinaztt.mes.quality.mapper.TestStandardMapper;
|
import com.chinaztt.mes.quality.mapper.TestStandardParamMapper;
|
import com.chinaztt.mes.quality.service.ReportSampleService;
|
import com.chinaztt.mes.quality.service.TestStandardParamService;
|
import com.chinaztt.mes.quality.service.TestStandardService;
|
import com.chinaztt.ztt.admin.api.entity.SysDictItem;
|
import com.chinaztt.ztt.common.core.util.R;
|
import lombok.AllArgsConstructor;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.RequestBody;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* 检测标准
|
*
|
* @author cxf
|
* @date 2021-04-22 09:03:06
|
*/
|
@Service
|
@AllArgsConstructor
|
@Transactional(rollbackFor = Exception.class)
|
public class TestStandardServiceImpl extends ServiceImpl<TestStandardMapper, TestStandard> implements TestStandardService {
|
private NumberGenerator<TestStandard> testStandardNumberGenerator;
|
private TestStandardParamMapper testStandardParamMapper;
|
private TestStandardParamService testStandardParamService;
|
private ParamService paramService;
|
private ReportSampleService reportSampleService;
|
private TestStandardMapper testStandardMapper;
|
private DictUtils dictUtils;
|
@Override
|
public boolean save(TestStandard testStandard) {
|
checkStandardNo(testStandard);
|
return SqlHelper.retBool(baseMapper.insert(testStandard));
|
}
|
|
@Override
|
public boolean updateById(TestStandard testStandard) {
|
checkStandardNo(testStandard);
|
return SqlHelper.retBool(baseMapper.updateById(testStandard));
|
}
|
|
private void checkStandardNo(TestStandard testStandard) {
|
if (StringUtils.isBlank(testStandard.getStandardNo())) {
|
// 1. 自动生成编号
|
testStandard.setStandardNo(testStandardNumberGenerator.generateNumberWithPrefix(TestStandard.DIGIT, TestStandard.PREFIX, TestStandard::getStandardNo));
|
} else {
|
// 2.判断是否重复
|
List<TestStandard> repeatNos = baseMapper.selectList(Wrappers.<TestStandard>query().lambda().eq(TestStandard::getStandardNo, testStandard.getStandardNo()).ne(TestStandard::getId, testStandard.getId()));
|
if (CollectionUtil.isNotEmpty(repeatNos)) {
|
throw new RuntimeException("编号重复");
|
}
|
}
|
}
|
public TestStandard copyTestStandard(TestStandard testStandard){
|
TestStandard newTestStandard = new TestStandard();
|
if(testStandard!=null){
|
newTestStandard.setStandardNo(testStandardNumberGenerator.generateNumberWithPrefix(TestStandard.DIGIT, TestStandard.PREFIX, TestStandard::getStandardNo));
|
newTestStandard.setStandardName(testStandard.getStandardName());
|
newTestStandard.setActive(true);
|
newTestStandard.setRemark(testStandard.getRemark());
|
newTestStandard.setState(testStandard.getState());
|
newTestStandard.setVersion(testStandard.getVersion());
|
baseMapper.insert(newTestStandard);
|
//查询检测的参数
|
List<TestStandardParam> testStandardParamList = testStandardParamMapper.selectList(Wrappers.<TestStandardParam>lambdaQuery().eq(TestStandardParam::getTestStandardId,testStandard.getId()));
|
for (TestStandardParam testStandardParam:testStandardParamList){
|
testStandardParam.setTestStandardId(newTestStandard.getId());
|
testStandardParamMapper.insert(testStandardParam);
|
}
|
}
|
return newTestStandard;
|
}
|
@Override
|
public R copyTestById(Long id) {
|
TestStandard testStandard = baseMapper.selectById(id);
|
if (testStandard!=null){
|
TestStandard newTestStandard = new TestStandard();
|
checkStandardNo(newTestStandard);
|
newTestStandard.setStandardName(testStandard.getStandardName());
|
newTestStandard.setVersion(testStandard.getVersion());
|
newTestStandard.setState(testStandard.getState());
|
newTestStandard.setRemark(testStandard.getRemark());
|
newTestStandard.setActive(testStandard.getActive());
|
newTestStandard.setJudgeFormula(testStandard.getJudgeFormula());
|
newTestStandard.setInspectionType(testStandard.getInspectionType());
|
newTestStandard.setOperationId(testStandard.getOperationId());
|
baseMapper.insert(newTestStandard);
|
List<TestStandardParam> testStandardParamList = testStandardParamMapper.selectList(Wrappers.<TestStandardParam>lambdaQuery().eq(TestStandardParam::getTestStandardId,testStandard.getId()));
|
if (CollectionUtil.isNotEmpty(testStandardParamList)){
|
for (TestStandardParam testStandardParam:testStandardParamList){
|
TestStandardParam newTestStandardParam = new TestStandardParam();
|
newTestStandardParam.setTestStandardId(newTestStandard.getId());
|
newTestStandardParam.setActive(testStandardParam.getActive());
|
newTestStandardParam.setCode(testStandardParam.getCode());
|
newTestStandardParam.setIndex(testStandardParam.getIndex());
|
newTestStandardParam.setParameterItem(testStandardParam.getParameterItem());
|
newTestStandardParam.setReferenceValue(testStandardParam.getReferenceValue());
|
newTestStandardParam.setType(testStandardParam.getType());
|
newTestStandardParam.setUnit(testStandardParam.getUnit());
|
newTestStandardParam.setParamType(testStandardParam.getParamType());
|
newTestStandardParam.setJudgeFormula(testStandardParam.getJudgeFormula());
|
newTestStandardParam.setValueFormula(testStandardParam.getValueFormula());
|
newTestStandardParam.setIsReference(testStandardParam.getIsReference());
|
newTestStandardParam.setWireCore(testStandardParam.getWireCore());
|
testStandardParamMapper.insert(newTestStandardParam);
|
}
|
}
|
}
|
return R.ok();
|
}
|
|
@Override
|
public void importExcel(List<TestStandardData> cachedDataList) {
|
// 根据标准编号分组
|
LinkedHashMap<String, List<TestStandardData>> groupMap = cachedDataList.stream().collect(Collectors.groupingBy(TestStandardData::getStandardNo, LinkedHashMap::new, Collectors.toList()));
|
|
List<TestStandardParam> paramList = new ArrayList<>();
|
// 循环新增
|
for (Map.Entry<String, List<TestStandardData>> dataList : groupMap.entrySet()) {
|
TestStandard testStandard = baseMapper.selectOne(Wrappers.<TestStandard>query().lambda().eq(TestStandard::getStandardNo, dataList.getKey()));
|
// 如果检测标准不存在则为新增操作
|
if (testStandard == null) {
|
testStandard = new TestStandard();
|
// 找出存在标准名称的主数据
|
Optional<TestStandardData> optional = dataList.getValue().stream().filter(e -> e.getStandardName() != null).findFirst();
|
if (!optional.isPresent()) {
|
throw new RuntimeException("标准编号为" + dataList.getValue().get(0).getStandardNo() + "不能没有标准名称");
|
}
|
//根据工序名称获取工序id
|
Long operationId = baseMapper.getOperationIdByOperationName(optional.get().getOperationName());
|
if(operationId != null){
|
testStandard.setOperationId(operationId);
|
}
|
testStandard.setStandardNo(optional.get().getStandardNo());
|
testStandard.setStandardName(optional.get().getStandardName());
|
testStandard.setJudgeFormula(org.springframework.util.StringUtils.trimAllWhitespace(optional.get().getJudgeFormula()));
|
if(false){
|
//用户在Excel中维护好直接导入，重复的原始code，系统无法替换
|
if(StringUtils.isNotBlank(testStandard.getJudgeFormula())){
|
if(testStandard.getJudgeFormula().contains("_")){
|
throw new RuntimeException("检测标准主表判断公式 = " + testStandard.getJudgeFormula() + " -> 包含字符 < _ > -> 被系统规则征用");
|
}
|
}
|
}
|
List<SysDictItem> dict = dictUtils.getDict("apply_report_type");
|
Boolean door = false;
|
if(CollectionUtils.isNotEmpty(dict)){
|
for(SysDictItem sysDictItem : dict){
|
if(sysDictItem.getLabel().equals(optional.get().getInspectionType())){
|
testStandard.setInspectionType(sysDictItem.getValue());
|
door = true;
|
break;
|
}
|
}
|
}else{
|
throw new RuntimeException("数据字典为空 -> 数据字典code = " + "【apply_report_type】");
|
}
|
//testStandard.setInspectionType(optional.get().getInspectionType());
|
if(!door){
|
throw new RuntimeException("检测类型 = " + "【" + optional.get().getInspectionType() + "】在数据字典中不存在");
|
}
|
baseMapper.insert(testStandard);
|
}
|
long index = 1;
|
for (TestStandardData testStandardData : dataList.getValue()) {
|
Param param = paramService.getOne(Wrappers.<Param>lambdaQuery().eq(Param::getCode, testStandardData.getCode()));
|
if (param == null) {
|
throw new RuntimeException("参数编号为"+ testStandardData.getCode() +"在参数列表中未找到");
|
}
|
if(true){
|
if(param.getCode().contains("_")){
|
throw new RuntimeException("参数编号 = " + param.getCode() + " -> 包含字符 < _ > -> 被系统规则征用");
|
}
|
if(testStandardData.getParameterItem().contains("_")){
|
throw new RuntimeException("检测项名称 = " + testStandardData.getParameterItem() + " -> 包含字符 < _ > -> 被系统规则征用");
|
}
|
}
|
TestStandardParam standardParam = new TestStandardParam();
|
//统一在检测标准批准时校正，保证导入时的效率
|
if(StringUtils.isNotBlank(testStandardData.getWireCore()) && testStandardData.getWireCore().trim().length() > 0){
|
if(testStandardData.getWireCore().contains("_")){
|
throw new RuntimeException("线芯 = " + testStandardData.getWireCore() + " -> 包含被系统规则征用的字符 = < _ >");
|
}else{
|
standardParam.setWireCore(testStandardData.getWireCore());//线芯
|
}
|
}
|
standardParam.setCode(param.getCode());
|
standardParam.setParameterItem(testStandardData.getParameterItem());
|
standardParam.setParameterFormat(param.getParameterFormat());
|
standardParam.setType(param.getType());
|
standardParam.setUnit(param.getUnit());
|
String referenceValue = StringUtils.isNotBlank(testStandardData.getReferenceValue1()) ? testStandardData.getReferenceValue1():"";
|
if (StringUtils.isNotBlank(testStandardData.getReferenceValue2())) {
|
referenceValue = referenceValue + "-" + testStandardData.getReferenceValue2();
|
}
|
standardParam.setReferenceValue(referenceValue);//参考值
|
standardParam.setTestStandardId(testStandard.getId());
|
standardParam.setIndex(index);
|
standardParam.setJudgeFormula(org.springframework.util.StringUtils.trimAllWhitespace(testStandardData.getParamJudgeFormula()));
|
standardParam.setValueFormula(org.springframework.util.StringUtils.trimAllWhitespace(testStandardData.getValueFormula()));
|
if(StringUtils.isNotBlank(testStandardData.getIsReference()) && testStandardData.getIsReference().equals("是")){
|
standardParam.setIsReference(true);
|
}else{
|
standardParam.setIsReference(false);
|
}
|
if(StringUtils.isNotBlank(testStandardData.getIsCheck()) && testStandardData.getIsCheck().equals("是")){
|
standardParam.setIsCheck(true);
|
}else{
|
standardParam.setIsCheck(false);
|
}
|
standardParam.setParamType(testStandardData.getParamType());
|
standardParam.setPosition(testStandardData.getPosition());
|
standardParam.setAisle(testStandardData.getAisle());
|
paramList.add(standardParam);
|
index++;
|
}
|
}
|
testStandardParamService.saveBatch(paramList, paramList.size());
|
}
|
|
@Override
|
public R removeByIds(List<Long> ids) {
|
List<Long> deleteIds = new ArrayList<>();
|
for (Long id : ids) {
|
int count = reportSampleService.count(Wrappers.<ReportSample>lambdaQuery().eq(ReportSample::getIsMoTestStandard, false).eq(ReportSample::getTestStandardId, id));
|
if (count == 0) {
|
deleteIds.add(id);
|
}
|
}
|
if (deleteIds.size() == 0) {
|
return R.failed("所选检测标准已被引用，无法删除");
|
}
|
this.baseMapper.deleteBatchIds(deleteIds);
|
testStandardParamMapper.deleteByStandardIds(deleteIds);
|
return R.ok();
|
}
|
|
@Override
|
public TestStandard getByNo(String no) {
|
TestStandard testStandard = testStandardMapper.selectOne(Wrappers.<TestStandard>lambdaQuery().eq(TestStandard::getActive, true)
|
.eq(TestStandard::getStandardNo, no));
|
if (testStandard == null) {
|
throw new RuntimeException("根据检测标准编号，未查到基础检测标准，请确认");
|
}
|
return testStandard;
|
}
|
|
@Override
|
public IPage<List<TestStandardDTO>> pageInfo(Page page, QueryWrapper<TestStandard> gen) {
|
return baseMapper.pageInfo(page,gen);
|
}
|
|
@Override
|
public TestStandardDTO getInfoById(Long id) {
|
return baseMapper.getInfoById(id);
|
}
|
|
@Override
|
public void approveTestStandard(TestStandard testStandard){
|
baseMapper.updateById(testStandard);
|
//保存明细（校正导入的检测标准参数）
|
List<TestStandardParam> testStandardParamList = testStandardParamMapper.selectList(Wrappers.<TestStandardParam>lambdaQuery().eq(TestStandardParam::getTestStandardId,testStandard.getId()));
|
testStandardParamService.saveList(testStandardParamList);
|
}
|
|
|
}
|
