package com.chinaztt.mes.quality.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.io.IoUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.service.impl.ServiceImpl;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.chinaztt.ifs.api.feign.IfsFeignClient;
import com.chinaztt.inspect.api.feign.InspectFeignClient;
import com.chinaztt.mes.common.numgen.NumberGenerator;
import com.chinaztt.mes.quality.dto.ReportSampleDTO;
import com.chinaztt.mes.quality.dto.ReportSampleItemDTO;
import com.chinaztt.mes.quality.dto.ValidateIsCheckItemDTO;
import com.chinaztt.mes.quality.entity.*;
import com.chinaztt.mes.quality.mapper.*;
import com.chinaztt.mes.quality.service.ReportSampleItemService;
import com.chinaztt.mes.quality.service.ReportSampleService;
import com.chinaztt.mes.quality.state.result.constant.ResultStateStringValues;
import com.chinaztt.mes.quality.utils.AutoJudgmentUtils;
import com.chinaztt.mes.quality.utils.ReportUtils;
import com.chinaztt.mes.quality.utils.SelfJudgmentUtils;
import com.chinaztt.mes.warehouse.dto.ValidateWeighPackagingDTO;
import com.chinaztt.ztt.common.core.util.R;
import com.chinaztt.ztt.common.oss.OssProperties;
import com.chinaztt.ztt.common.oss.service.OssTemplate;
import com.chinaztt.ztt.common.security.util.SecurityUtils;
import lombok.AllArgsConstructor;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.math.NumberUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.InputStream;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 检测汇报样品表
 *
 * @author cxf
 * @date 2021-04-06 14:29:44
 */
@Slf4j
@Service
@AllArgsConstructor
@Transactional(rollbackFor = Exception.class)
public class ReportSampleServiceImpl extends ServiceImpl<ReportSampleMapper, ReportSample> implements ReportSampleService {
	private final OssProperties ossProperties;
	private final OssTemplate minioTemplate;
	private NumberGenerator<ReportSample> reportSampleNumberGenerator;
	private ReportSampleItemMapper reportSampleItemMapper;
	private ReportMapper reportMapper;
	private ReportUtils reportUtils;
	private SelfJudgmentUtils selfJudgmentUtils;
	private ApplyPartMapper applyPartMapper;
	private ReportSampleAttachmentMapper reportSampleAttachmentMapper;
	private TestStandardMapper testStandardMapper;

	private ReportSampleItemService reportSampleItemService;

	private InspectFeignClient inspectFeignClient;


	@Override
	public boolean saveBatchList(List<ReportSample> reportSampleList) {
		for (ReportSample reportSample : reportSampleList) {
			reportSample.setSampleNo(reportSampleNumberGenerator.generateNumberWithPrefix(ReportSample.DIGIT, ReportSample.PREFIX, ReportSample::getSampleNo));
			//这里增加一个检测标准id字段值的自动校正补充功能
			if(true || reportSample.getTestStandardId() == null){//改成直接矫正，applyPart表中的检测标准不准
				//根据产出系统编号、检测汇报id获取检测制造订单检测标准id
				Long moTestStandardId = baseMapper.getMoTestStandardId(reportSample.getReportId(),reportSample.getSystemNo());
				String moTestStandardNo = baseMapper.getMoTestStandardNoById(moTestStandardId);
				reportSample.setTestStandardId(moTestStandardId);
				reportSample.setTestStandardNo(moTestStandardNo);
			}
			baseMapper.insert(reportSample);
			if (StringUtils.isNotBlank(reportSample.getTestStandardNo())) {
				// 这边查的是制造订单的检测标准
				reportSampleItemMapper.insertMoSampleItemsById(reportSample);
				// 获取配置继承检测参数的检测汇报项
				List<ReportSampleItem> extendsItemList =
						reportSampleItemMapper.selectList(Wrappers.<ReportSampleItem>lambdaQuery().eq(ReportSampleItem::getReportSampleId, reportSample.getId())
								.isNotNull(ReportSampleItem::getExtendsTestStandardParamId));
				if (CollectionUtil.isEmpty(extendsItemList)) {
					return true;
				}
				List<Long> technologyDocumentStandardParamIdList =
						extendsItemList.stream().map(ReportSampleItem::getExtendsTestStandardParamId).collect(Collectors.toList());
				Set<String> systemNoSet = new HashSet<>();
				// 将自己系统编号加进来，有可能继承检测项是同一道工序下，因此根据投入找不到检测项
				systemNoSet.add(reportSample.getSystemNo());
				getInputSystemNoByOutReportSampleSystemNo(systemNoSet, Collections.singletonList(reportSample.getSystemNo()));
				// 获取继承检验参数项检测结果
				List<ReportSampleItem> parentItemList =
						reportSampleItemMapper.getParentItemList(technologyDocumentStandardParamIdList, systemNoSet);
				Map<Long, List<ReportSampleItem>> extendsItemMap =
						extendsItemList.stream().collect(Collectors.groupingBy(ReportSampleItem::getExtendsTestStandardParamId));
				Map<Long, ReportSampleItem> parentItemMap =
						parentItemList.stream().collect(Collectors.toMap(ReportSampleItem::getTechnologyDocumentStandardParamId, item -> item, (k1, k2) -> k1));
				// 将继承的参数项结果值，复制到当前检测结果中
				for (Map.Entry<Long, List<ReportSampleItem>> entry : extendsItemMap.entrySet()) {
					if (!parentItemMap.containsKey(entry.getKey())) {
						entry.getValue().forEach(v->v.setExtendsResultFlag(Boolean.FALSE));
					}else{
						entry.getValue().forEach(v->{
							v.setItemValue(parentItemMap.get(entry.getKey()).getItemValue());
							v.setExtendsResultFlag(Boolean.TRUE);
						});
					}
				}
				reportSampleItemService.updateBatchById(extendsItemList);
			}
		}
		return true;
	}

	/**
	 * 递归获取当前产出的投入
	 * @param systemNo
	 * @return
	 */
	private void getInputSystemNoByOutReportSampleSystemNo(Set<String>systemNoSet, List<String> systemNos) {
		// 获取当前系统号产出的投入系统号
		List<String> inputSystemNos =
				reportSampleItemMapper.getInputSystemNoByOutReportSampleSystemNo(systemNos);
		if (CollectionUtil.isNotEmpty(inputSystemNos)) {
			getInputSystemNoByOutReportSampleSystemNo(systemNoSet, inputSystemNos);
			systemNoSet.addAll(inputSystemNos);
		}
	}


	@Override
	public List<ReportSampleDTO> getReportSampleList(QueryWrapper<ReportSampleDTO> gen) {
		return baseMapper.getReportSampleList(gen);
	}

	@Override
	public ReportSample updateSampleById(ReportSample reportSample) {
		// 如果检测标准编号被修改了，需要替换样品检测项目
		ReportSample oldReportSample = baseMapper.selectById(reportSample.getId());
		String oldTestStandardNo = oldReportSample.getTestStandardNo();
		String testStandardNo = reportSample.getTestStandardNo();
		if (StringUtils.isNotBlank(oldTestStandardNo) && StringUtils.isNotBlank(testStandardNo) && oldTestStandardNo.trim().equals(testStandardNo.trim())) {
		} else {
			// 先去查询检测标准编号对应的检测标准
			TestStandard newTestStandard = testStandardMapper.selectOne(Wrappers.<TestStandard>lambdaQuery().eq(TestStandard::getActive, true)
					.eq(TestStandard::getStandardNo, testStandardNo));
			if (newTestStandard == null) {
				throw new RuntimeException("质量-检测标准中不存在输入的检测标准编号，请确认");
			}
			// 样品的检测标准编号被修改，就认为是质量-检测标准
			reportSample.setIsMoTestStandard(false);
			reportSample.setTestStandardId(newTestStandard.getId());
			reportSampleItemMapper.delete(Wrappers.<ReportSampleItem>query().lambda().eq(ReportSampleItem::getReportSampleId, reportSample.getId()));
			// 这边查的是检测标准
			reportSampleItemMapper.insertSampleItemsById(reportSample);
		}
		baseMapper.updateById(reportSample);
		return reportSample;
	}

	@Override
	public ReportSample updateSampleByIdV2(ReportSample reportSample) {
		// 如果检测标准编号被修改了，需要替换样品检测项目
		ReportSample oldReportSample = baseMapper.selectById(reportSample.getId());
		String oldTestStandardNo = oldReportSample.getTestStandardNo();
		String testStandardNo = reportSample.getTestStandardNo();
		if (StringUtils.isNotBlank(oldTestStandardNo) && StringUtils.isNotBlank(testStandardNo) && oldTestStandardNo.trim().equals(testStandardNo.trim())) {
		} else {
			// 判断是否是车间订单的检测标准
			if (reportSample.getIsMoTestStandard()) {
				reportSampleItemMapper.delete(Wrappers.<ReportSampleItem>query().lambda().eq(ReportSampleItem::getReportSampleId, reportSample.getId()));
				reportSampleItemMapper.insertMoSampleItemsById(reportSample);
			} else {
				// 先去查询检测标准编号对应的检测标准
				TestStandard newTestStandard = testStandardMapper.selectOne(Wrappers.<TestStandard>lambdaQuery().eq(TestStandard::getActive, true)
						.eq(TestStandard::getStandardNo, testStandardNo));
				if (newTestStandard == null) {
					throw new RuntimeException("质量-检测标准中不存在输入的检测标准编号，请确认");
				}
				// 样品的检测标准编号被修改，就认为是质量-检测标准
				reportSample.setTestStandardId(newTestStandard.getId());
				reportSampleItemMapper.delete(Wrappers.<ReportSampleItem>query().lambda().eq(ReportSampleItem::getReportSampleId, reportSample.getId()));
				// 这边查的是检测标准
				reportSampleItemMapper.insertSampleItemsById(reportSample);
			}
		}
		baseMapper.updateById(reportSample);
		return reportSample;
	}


	@Override
	public boolean deleteById(Long id) {
		// 删除检测标准数据
		reportSampleItemMapper.delete(Wrappers.<ReportSampleItem>query().lambda().eq(ReportSampleItem::getReportSampleId, id));
		reportSampleAttachmentMapper.delete(Wrappers.<ReportSampleAttachment>lambdaQuery().eq(ReportSampleAttachment::getSampleId, id));
		return SqlHelper.retBool(baseMapper.deleteById(id));
	}

	@Override
	public List<ReportSampleItemDTO> getSampleItemsById(ReportSampleDTO reportSampleDTO) {
		return reportSampleItemMapper.getSampleItemsById(reportSampleDTO);
	}

	@Override
	public List<ReportSampleItemDTO> getSampleSysItemsById(ReportSampleDTO reportSampleDTO) {
		return reportSampleItemMapper.getSampleSysItemsById(reportSampleDTO);
	}

	@Override
	public R uploadFile(MultipartFile file, Long sampleId) {
		String fileName = IdUtil.simpleUUID() + StrUtil.DOT + FileUtil.extName(file.getOriginalFilename());
		String url = String.format("/mes/reportSample/%s/%s", ossProperties.getBucketName(), fileName);
		try {
			minioTemplate.putObject(ossProperties.getBucketName(), fileName, file.getInputStream());

			ReportSampleAttachment attachment = new ReportSampleAttachment();
			attachment.setOriginal(file.getOriginalFilename());
			attachment.setPath(url);
			attachment.setFileName(fileName);
			attachment.setSampleId(sampleId);
			reportSampleAttachmentMapper.insert(attachment);

		} catch (Exception e) {
			log.error("上传失败", e);
			TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
			return R.failed(e.getLocalizedMessage());
		}
		return R.ok();
	}

	@Override
	@SneakyThrows
	public R<Boolean> deleteFile(String fileName) {
		ReportSampleAttachment attachment = reportSampleAttachmentMapper.selectOne(Wrappers.<ReportSampleAttachment>lambdaQuery().eq(ReportSampleAttachment::getFileName, fileName));
		minioTemplate.removeObject(ossProperties.getBucketName(), attachment.getFileName());
		reportSampleAttachmentMapper.deleteById(attachment.getId());
		return R.ok();
	}

	@Override
	public List<ReportSampleAttachment> getReportSampleAttachment(Long id) {
		return reportSampleAttachmentMapper.selectList(Wrappers.<ReportSampleAttachment>lambdaQuery().eq(ReportSampleAttachment::getSampleId, id));
	}

	@Override
	public void getFile(String bucket, String fileName, HttpServletResponse response) {
		try (InputStream inputStream = minioTemplate.getObject(bucket, fileName)) {
			response.setContentType("application/octet-stream; charset=UTF-8");
			IoUtil.copy(inputStream, response.getOutputStream());
		} catch (Exception e) {
			log.error("文件读取异常: {}", e.getLocalizedMessage());
		}
	}

	@Override
	public ReportSampleDTO saveSelfSampleItem(ReportSampleDTO reportSampleDTO) {
		// 1.同步创建检测汇报
		Report report = new Report();
		report.setRemark(reportSampleDTO.getOutBatchNo());
		report.setReportType("04self");
		report.setReportPerson(SecurityUtils.getUser().getUsername());
		reportUtils.checkReportNo(report);
		reportMapper.insert(report);
		// 2.同步创建检测汇报零件
		ApplyPart applyPart = new ApplyPart();
		applyPart.setReportId(report.getId());
		applyPart.setLotBatchNo(reportSampleDTO.getOutBatchNo());
		applyPart.setSystemNo(reportSampleDTO.getSystemNo());
		applyPart.setPartId(reportSampleDTO.getPartId());
		applyPart.setPartNo(reportSampleDTO.getPartNo());
		applyPart.setPartDesc(reportSampleDTO.getPartName());
		applyPart.setIsErp(false);
		applyPart.setQtyArrived(reportSampleDTO.getQtyArrived().stripTrailingZeros().toPlainString());
		applyPart.setUnqualifiedArrived("0");
		applyPart.setMoTestStandardId(reportSampleDTO.getTestStandardId());
		applyPart.setTestStandardNo(reportSampleDTO.getTestStandardNo());
		applyPartMapper.insert(applyPart);
		// 修改检测结果状态为检测中
		reportSampleDTO.setCheckStatus(ResultStateStringValues.TESTING);
		reportSampleDTO.setIsUsed(false);
		// 3.同步创建样品
		reportSampleDTO.setReportId(report.getId());
		reportSampleDTO.setSampleNo(reportSampleNumberGenerator.generateNumberWithPrefix(ReportSample.DIGIT, ReportSample.PREFIX, ReportSample::getSampleNo));
		baseMapper.insert(reportSampleDTO);
		// 4.同步创建样品检测项
		List<ReportSampleItemDTO> reportSampleItemList = reportSampleDTO.getReportSampleItemList();
		if (CollectionUtil.isNotEmpty(reportSampleItemList)) {
			reportSampleItemList.stream().forEach(item -> {
				item.setReportSampleId(reportSampleDTO.getId());
				reportSampleItemMapper.insert(item);
			});
		}
		return reportSampleDTO;
	}

	@Override
	public ReportSampleDTO getReportSampleForSelf(ReportSampleDTO reportSampleDTO) {
		reportSampleDTO = baseMapper.getReportSampleForSelf(reportSampleDTO);
		if (reportSampleDTO != null) {
			reportSampleDTO.setReportSampleItemList(reportSampleItemMapper.getSampleItemsById(reportSampleDTO));
		}
		return reportSampleDTO;
	}

	@Override
	public ReportSampleDTO autoMoveStock(ReportSampleDTO reportSampleDTO) {
		reportSampleDTO.setReportSampleItemList(reportSampleItemMapper.getSampleItemsById(reportSampleDTO));
		reportSampleDTO.setIsSelfQualified(reportSampleDTO.getIsQualified());
		reportSampleDTO.setCheckStatus(ResultStateStringValues.TESTED);
		reportSampleDTO.setIsUsed(reportSampleDTO.getIsQualified());
		selfJudgmentUtils.autoMoveStock(reportSampleDTO);
		return reportSampleDTO;
	}


	@Override
	public R judgmentSampleCheck(ReportSampleDTO reportSampleDTO) {
		// 1.判断各个检测项是否合格
		List<ReportSampleItemDTO> reportSampleItemList = reportSampleItemMapper.getSampleItemsById(reportSampleDTO);
		List<ReportSampleItemDTO> isCheckSampleItemList = reportSampleItemList.stream().filter(ReportSampleItem::getIsCheck).filter(a->StringUtils.isBlank(a.getItemValue())).collect(Collectors.toList());
		if(CollectionUtils.isNotEmpty(isCheckSampleItemList)){
			List<String> isCheckItemNameList = isCheckSampleItemList.stream().map(ReportSampleItem::getItemName).collect(Collectors.toList());
			return R.ok(ValidateIsCheckItemDTO.builder().success(Boolean.FALSE).message("以下抽检项未填，是否继续"+isCheckItemNameList.toString()).build());
		}else{
			return R.ok(ValidateIsCheckItemDTO.builder().success(Boolean.TRUE).build());
		}
	}

	@Override
	public ReportSampleDTO autoJudgmentSample(ReportSampleDTO reportSampleDTO) {
		// 1.判断各个检测项是否合格
		List<ReportSampleItemDTO> reportSampleItemList = reportSampleItemMapper.getSampleItemsById(reportSampleDTO);
		List<ReportSampleItemDTO> isCheckSampleItemList = reportSampleItemList.stream().filter(ReportSampleItem::getIsCheck).filter(a->StringUtils.isBlank(a.getItemValue())).collect(Collectors.toList());
		if(CollectionUtils.isNotEmpty(isCheckSampleItemList)){
			reportSampleItemList.removeAll(isCheckSampleItemList);
		}
		if (CollectionUtil.isNotEmpty(reportSampleItemList)) {
			// 1.1判断值公式
			reportSampleItemList.stream().forEach(reportSampleItem -> {
				// 检测项值和值公式都为空，才去帮忙计算
				if (StringUtils.isNotBlank(reportSampleItem.getValueFormula())) {
					String expression = AutoJudgmentUtils.replace(reportSampleItem.getValueFormula(), reportSampleItemList);
					try {
						reportSampleItem.setItemValue(AutoJudgmentUtils.computeResult(expression));
					} catch (Exception e) {
						throw new RuntimeException("明细行检测项编号 = 【" + reportSampleItem.getItemCode() + "】 -> 表达式 = 【" + expression + "】异常");
						//throw new RuntimeException("检测项编号为" + reportSampleItem.getItemCode() + "公式不正确，请检查后重试");
					}
					if (StringUtils.isNotBlank(reportSampleItem.getParameterFormat())) {
						if (NumberUtils.isCreatable(reportSampleItem.getItemValue())) {

							DecimalFormat decimalFormat = new DecimalFormat(reportSampleItem.getParameterFormat().replace("#", "#0"));
							reportSampleItem.setItemValue(decimalFormat.format(new BigDecimal(reportSampleItem.getItemValue())));
						}
					}
				}
			});
			// 1.2判断合格公式
			reportSampleItemList.stream().forEach(reportSampleItem -> {
				if (StringUtils.isNotBlank(reportSampleItem.getJudgeFormula())) {
					// 根据编号替换值
					String expression = AutoJudgmentUtils.replace(reportSampleItem.getJudgeFormula(), reportSampleItemList);
					// 再判断
					reportSampleItem.setIsQualified(AutoJudgmentUtils.computeExpression(expression,"->检测项编号=" + reportSampleItem.getItemCode()));
				}
				reportSampleItemMapper.updateById(reportSampleItem);
			});

		}
		// 2.判断整体是否合格
		String sampleExpression = baseMapper.selectSampleExpressionById(reportSampleDTO.getId());
		if (StringUtils.isNotBlank(sampleExpression)) {
			sampleExpression = AutoJudgmentUtils.replace(sampleExpression, reportSampleItemList);
			reportSampleDTO.setIsQualified(AutoJudgmentUtils.computeExpression(sampleExpression,"->业务类别=" + "判断整体是否合格"));
			baseMapper.updateById(reportSampleDTO);
		}
		return reportSampleDTO;
	}

	@Override
	public ReportSampleItemDTO autoJudgmentSampleSingle(ReportSampleItemDTO reportSampleItemDTO){
		if(StringUtils.isNotBlank(reportSampleItemDTO.getItemValue()) && StringUtils.isNotBlank(reportSampleItemDTO.getJudgeFormula()) && StringUtils.isBlank(reportSampleItemDTO.getValueFormula())){
			//如果检测值及判断公式存在，且值计算公式不存在，则继续执行（如果检测值本身就是自动计算出来的，则不在本次功能范围内）
			List<ReportSampleItemDTO> reportSampleItemList = new ArrayList<>();
			reportSampleItemList.add(reportSampleItemDTO);
			// 根据编号替换值
			String expression = AutoJudgmentUtils.replace(reportSampleItemDTO.getJudgeFormula(), reportSampleItemList);
			// 再判断
			try{
				reportSampleItemDTO.setIsQualified(AutoJudgmentUtils.computeExpression(expression,"->检测项编号=" + reportSampleItemDTO.getItemCode()));
				//reportSampleItemMapper.updateById(reportSampleItemDTO);//不用保存结果
			}catch(Exception e){
				//单条实时自动判定中屏蔽异常
			}
		}
		if(StringUtils.isNotBlank(reportSampleItemDTO.getItemValue()) && StringUtils.isBlank(reportSampleItemDTO.getJudgeFormula())){
			reportSampleItemDTO.setIsQualified(true);//如果实测值不为空，且计算公式为空，则默认结果为合格
		}
		return reportSampleItemDTO;
	}


	@Override
	public List<ReportSampleItemDTO> dataAcquisition(Long id,String sn) {
		List<ReportSampleItem> reportSampleItemList = reportSampleItemMapper.selectList(Wrappers.<ReportSampleItem>lambdaQuery()
				.eq(ReportSampleItem::getReportSampleId,id)
				.eq(ReportSampleItem::getParamType,"采集项"));
		Map<String,String> map = new HashMap<>();
		//map.put("pdf_name","18012606007");
		map.put("pdf_name",sn);
/*		map.put("1","20℃导体电阻—红色主线芯1#");
		map.put("2","20℃导体电阻—白色主线芯1#");
		map.put("pdf_name",sn);*/
        for(ReportSampleItem reportSampleItem:reportSampleItemList){
			map.put(reportSampleItem.getSort()+"",reportSampleItem.getItemName().replace("-","—"));
		}
		R res = inspectFeignClient.getInfo(map);
		if(res==null || res.getCode()==1){
			throw new RuntimeException("请求inspect失败");
		}
		HashMap<String, String> hashMap = JSONObject.parseObject(JSONObject.toJSONString(res.getData()), HashMap.class);
		Set<String> keySet = hashMap.keySet();
		List<ReportSampleItemDTO> reportSampleItemInputList = null;
		if(CollectionUtil.isNotEmpty(keySet)) {
			List<Long> keyList = keySet.stream().map(Long::valueOf).collect(Collectors.toList());
			reportSampleItemInputList = reportSampleItemMapper.getSampleSysItemsBySortAndId(id, keyList);
		}

		List<ReportSampleItemDTO> returnList = new ArrayList<>();
		Iterator <Map.Entry< String, String >> iterator = hashMap.entrySet().iterator();
		while (iterator.hasNext()) {
			Map.Entry< String, String > entry = iterator.next();
			Long key = Long.valueOf(entry.getKey());

			for (ReportSampleItemDTO reportSampleItemDTO:reportSampleItemInputList) {
				if(key.equals(reportSampleItemDTO.getSort())){
					reportSampleItemDTO.setItemValue(entry.getValue());
					//判断是否合格
					if(StringUtils.isNotBlank(reportSampleItemDTO.getItemValue()) && StringUtils.isNotBlank(reportSampleItemDTO.getJudgeFormula()) && StringUtils.isBlank(reportSampleItemDTO.getValueFormula())){
						//如果检测值及判断公式存在，且值计算公式不存在，则继续执行（如果检测值本身就是自动计算出来的，则不在本次功能范围内）
						List<ReportSampleItemDTO> reportSampleItemDTOList = new ArrayList<>();
						reportSampleItemDTOList.add(reportSampleItemDTO);
						// 根据编号替换值
						String expression = AutoJudgmentUtils.replace(reportSampleItemDTO.getJudgeFormula(), reportSampleItemDTOList);
						// 再判断
						try{
							reportSampleItemDTO.setIsQualified(AutoJudgmentUtils.computeExpression(expression,"->检测项编号=" + reportSampleItemDTO.getItemCode()));
							//reportSampleItemMapper.updateById(reportSampleItemDTO);//不用保存结果
						}catch(Exception e){
							//单条实时自动判定中屏蔽异常
						}
					}
					if(StringUtils.isNotBlank(reportSampleItemDTO.getItemValue()) && StringUtils.isBlank(reportSampleItemDTO.getJudgeFormula())){
						reportSampleItemDTO.setIsQualified(true);//如果实测值不为空，且计算公式为空，则默认结果为合格
					}
					returnList.add(reportSampleItemDTO);
				}
			}
		}
		return returnList;
	}

    @Override
    public boolean insert(ReportSample reportSample) {
		reportSample.setSampleNo(reportSampleNumberGenerator.generateNumberWithPrefix(ReportSample.DIGIT, ReportSample.PREFIX, ReportSample::getSampleNo));
		return this.save(reportSample);
	}

    @Override
    public List<String> getTestStandardNoBySnOrPartId(String partBatchNo, Long partId, String testType) {
		return this.baseMapper.getTestStandardNoBySnOrPartId(partBatchNo, partId, testType);
    }


}