package com.chinaztt.mes.quality.utils;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
|
import com.chinaztt.mes.quality.dto.ReportSampleItemDTO;
|
import com.chinaztt.mes.quality.entity.ReportSampleItem;
|
import com.chinaztt.mes.quality.entity.TestStandardParam;
|
import lombok.AllArgsConstructor;
|
import org.apache.commons.lang3.math.NumberUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.stereotype.Service;
|
|
import javax.script.ScriptEngine;
|
import javax.script.ScriptEngineManager;
|
import javax.script.ScriptException;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.List;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author: cxf
|
* @Date: 2021/09/07 16:00
|
*/
|
@Service
|
@AllArgsConstructor
|
public class AutoJudgmentUtils {
|
private static final Logger logger = LoggerFactory.getLogger(AutoJudgmentUtils.class);
|
private static final ScriptEngineManager manager = new ScriptEngineManager();
|
|
/**
|
* 运算包括：
|
* 1.正常运算 + - * || && 以及x==true
|
*/
|
public static Boolean computeExpression(String expression,String hintMsg) {
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(expression);
|
if (valueMatcher.find()) {
|
logger.error(expression);
|
throw new RuntimeException("公式存在不能处理的检测项：" + valueMatcher.group() + " -> 表达式 = 【" + expression + "】明细行检测项编号 = " + hintMsg);
|
}
|
ScriptEngine se = manager.getEngineByName("js");
|
String[] split;
|
Boolean bl = false;
|
Boolean eval;
|
expression = expression.replace("≥", ">=");
|
expression = expression.replace("≤", "<=");
|
expression = expression.replace("；", ";");
|
try {
|
split = expression.split(";");
|
for (int i = 0; i < split.length; i++) {
|
String s = split[i];
|
eval = (Boolean) se.eval(s);
|
bl = bl || eval;
|
}
|
} catch (ScriptException e) {
|
logger.error(expression);
|
throw new RuntimeException("执行判定表达式 = 【" + expression + "】失败 -> 明细行检测项编号 = " + hintMsg);
|
}
|
return bl;
|
}
|
|
/**
|
* 求值运算包括：
|
* 1.正常运算 + - * || && 以及x==true
|
*/
|
public static String computeResult(String expression) throws Exception {
|
ScriptEngine se = manager.getEngineByName("js");
|
String result = "";
|
expression = expression.replace("≥", ">=");
|
expression = expression.replace("≤", "<=");
|
expression = expression.replace("；", ";");
|
// try {
|
result = se.eval(expression).toString();
|
// } catch (ScriptException e) {
|
// logger.error(expression);
|
// throw new RuntimeException("公式不规范，无法执行：" + expression);
|
// }
|
return result;
|
}
|
|
/**
|
* 处理公式
|
*
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
public static String replace(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
judgeFormula = replacePassFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replacePassAllFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceAvgFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceMaxFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceMinFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replacePiFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceSqrtFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replacePowFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceLogFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceLnFunction(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceSTDValue(judgeFormula, reportSampleItemList);
|
judgeFormula = replaceValue(judgeFormula, reportSampleItemList);
|
return judgeFormula;
|
}
|
|
/**
|
* 所有检测项都通过函数
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
private static String replacePassAllFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher passAllMatcher = FunctionConfig.PATTEN_PASSALL.matcher(judgeFormula);
|
List<String> passAllFunctionList = new ArrayList<String>();
|
addMatcherGroup(passAllFunctionList, passAllMatcher);
|
if (CollectionUtil.isNotEmpty(passAllFunctionList)) {
|
boolean flag = true;
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
if (!reportSampleItem.getIsQualified()) {
|
flag = false;
|
break;
|
}
|
}
|
judgeFormula = judgeFormula.replace(judgeFormula, flag+"");
|
}
|
// 这边再判断比对一下，预防不规范的写法
|
passAllMatcher = FunctionConfig.PATTEN_PASSALL.matcher(judgeFormula);
|
passAllFunctionList = new ArrayList<String>();
|
addMatcherGroup(passAllFunctionList, passAllMatcher);
|
if (CollectionUtil.isNotEmpty(passAllFunctionList)) {
|
throw new RuntimeException("公式存在无法处理的合格函数：" + judgeFormula);
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换值-最小值函数
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
private static String replaceMinFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher minMatcher = FunctionConfig.PATTEN_MIN.matcher(judgeFormula);
|
List<String> minFunctionList = new ArrayList<String>();
|
addMatcherGroup(minFunctionList, minMatcher);
|
if (CollectionUtil.isNotEmpty(minFunctionList)) {
|
for (int i = 0; i < minFunctionList.size(); i++) {
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(minFunctionList.get(i));
|
List<String> valueList = new ArrayList<String>();
|
addMatcherGroup(valueList, valueMatcher);
|
// 平均值函数里面至少有一个参数项
|
if (CollectionUtil.isEmpty(valueList)) {
|
throw new RuntimeException("公式不规范，最小值函数里面至少有一个参数项：" + minFunctionList.get(i));
|
}
|
// 处理平均值函数，然后直接替换公式
|
List<String> minItemList = new ArrayList<String>();
|
for (int j = 0; j < valueList.size(); j++) {
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
String coed = "V[" + reportSampleItem.getItemCode() + "]";
|
if (valueList.get(j).contains(coed)) {
|
// 平均值函数，几个参数有值，就按几个去计算
|
if (StringUtils.isNotBlank(reportSampleItem.getItemValue())) {
|
minItemList.add(reportSampleItem.getItemValue());
|
}
|
break;
|
}
|
}
|
}
|
|
String replacement = "";
|
if (CollectionUtil.isNotEmpty(minItemList)) {
|
replacement = Collections.min(minItemList);
|
} else {
|
replacement = "0";
|
}
|
judgeFormula = judgeFormula.replace(minFunctionList.get(i), replacement);
|
}
|
}
|
// 这边再判断比对一下，预防不规范的写法
|
minMatcher = FunctionConfig.PATTEN_MIN.matcher(judgeFormula);
|
minFunctionList = new ArrayList<String>();
|
addMatcherGroup(minFunctionList, minMatcher);
|
if (CollectionUtil.isNotEmpty(minFunctionList)) {
|
throw new RuntimeException("公式存在无法处理的最小值函数：" + judgeFormula);
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换值-最大值函数
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
private static String replaceMaxFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher maxMatcher = FunctionConfig.PATTEN_MAX.matcher(judgeFormula);
|
List<String> maxFunctionList = new ArrayList<String>();
|
addMatcherGroup(maxFunctionList, maxMatcher);
|
if (CollectionUtil.isNotEmpty(maxFunctionList)) {
|
for (int i = 0; i < maxFunctionList.size(); i++) {
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(maxFunctionList.get(i));
|
List<String> valueList = new ArrayList<String>();
|
addMatcherGroup(valueList, valueMatcher);
|
// 平均值函数里面至少有一个参数项
|
if (CollectionUtil.isEmpty(valueList)) {
|
throw new RuntimeException("公式不规范，最大值函数里面至少有一个参数项：" + maxFunctionList.get(i));
|
}
|
// 处理平均值函数，然后直接替换公式
|
List<String> avgItemList = new ArrayList<String>();
|
for (int j = 0; j < valueList.size(); j++) {
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
String coed = "V[" + reportSampleItem.getItemCode() + "]";
|
if (valueList.get(j).contains(coed)) {
|
// 平均值函数，几个参数有值，就按几个去计算
|
if (StringUtils.isNotBlank(reportSampleItem.getItemValue())) {
|
avgItemList.add(reportSampleItem.getItemValue());
|
}
|
break;
|
}
|
}
|
}
|
|
String replacement = "";
|
if (CollectionUtil.isNotEmpty(avgItemList)) {
|
replacement = Collections.max(avgItemList);
|
} else {
|
replacement = "0";
|
}
|
judgeFormula = judgeFormula.replace(maxFunctionList.get(i), replacement);
|
}
|
}
|
// 这边再判断比对一下，预防不规范的写法
|
maxMatcher = FunctionConfig.PATTEN_MAX.matcher(judgeFormula);
|
maxFunctionList = new ArrayList<String>();
|
addMatcherGroup(maxFunctionList, maxMatcher);
|
if (CollectionUtil.isNotEmpty(maxFunctionList)) {
|
throw new RuntimeException("公式存在无法处理的平均值函数：" + judgeFormula);
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换值-π
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
private static String replacePiFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
// 将公式里的剩下的pi替换为π值
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
String coed = "pi";
|
if (judgeFormula.contains(coed)) {
|
if (StringUtils.isBlank(reportSampleItem.getItemValue())) {
|
throw new RuntimeException("参与计算的检测项值不能为空");
|
} else {
|
judgeFormula = judgeFormula.replace(coed, String.valueOf(Math.PI));
|
}
|
}
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 开根号函数
|
* @param judgeFormula
|
* @param reportSampleItemList
|
* @return
|
*/
|
private static String replaceSqrtFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher sqrtMatcher = FunctionConfig.PATTEN_SQRT.matcher(judgeFormula);
|
List<String> sqrtFunctionList = new ArrayList<String>();
|
addMatcherGroup(sqrtFunctionList, sqrtMatcher);
|
if (CollectionUtil.isNotEmpty(sqrtFunctionList)) {
|
for (int i = 0; i < sqrtFunctionList.size(); i++) {
|
judgeFormula = judgeFormula.replace("sqrt", "Math.sqrt");
|
}
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 平方函数
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
private static String replacePowFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher powMatcher = FunctionConfig.PATTEN_POW.matcher(judgeFormula);
|
List<String> powFunctionList = new ArrayList<String>();
|
addMatcherGroup(powFunctionList, powMatcher);
|
if (CollectionUtil.isNotEmpty(powFunctionList)) {
|
for (int i = 0; i < powFunctionList.size(); i++) {
|
judgeFormula = judgeFormula.replace("pow", "Math.pow");
|
}
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* log函数
|
* @param judgeFormula
|
* @param reportSampleItemList
|
* @return
|
*/
|
private static String replaceLogFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher logMatcher = FunctionConfig.PATTEN_LOG.matcher(judgeFormula);
|
List<String> logFunctionList = new ArrayList<String>();
|
addMatcherGroup(logFunctionList, logMatcher);
|
if (CollectionUtil.isNotEmpty(logFunctionList)) {
|
for (int i = 0; i < logFunctionList.size(); i++) {
|
if (org.apache.commons.lang3.StringUtils.countMatches(logFunctionList.get(i), "(") > 1) {
|
String substring = judgeFormula.substring(judgeFormula.indexOf(logFunctionList.get(i)));
|
int number = org.apache.commons.lang3.StringUtils.countMatches(logFunctionList.get(i), "(");
|
int last = org.apache.commons.lang3.StringUtils.ordinalIndexOf(substring, ")", number);
|
String result = substring.substring(0, last + 1);
|
judgeFormula = judgeFormula.replace(result, "Math.log" + result.substring(3) + "/Math.log(10)");
|
} else {
|
judgeFormula = judgeFormula.replace(logFunctionList.get(i), "Math.log" + logFunctionList.get(i).substring(3) + "/Math.log(10)");
|
}
|
}
|
}
|
return judgeFormula;
|
}
|
|
private static String replaceLnFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher lnMatcher = FunctionConfig.PATTEN_LN.matcher(judgeFormula);
|
List<String> lnFunctionList = new ArrayList<String>();
|
addMatcherGroup(lnFunctionList, lnMatcher);
|
if (CollectionUtil.isNotEmpty(lnFunctionList)) {
|
for (int i = 0; i < lnFunctionList.size(); i++) {
|
judgeFormula = judgeFormula.replace(lnFunctionList.get(i), "Math.log");
|
}
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 获取标准值
|
* @param judgeFormula
|
* @param reportSampleItemList
|
* @return
|
*/
|
private static String replaceSTDValue(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher stdMatcher = FunctionConfig.PATTEN_STD.matcher(judgeFormula);
|
List<String> stdFunctionList = new ArrayList<String>();
|
addMatcherGroup(stdFunctionList, stdMatcher);
|
if (CollectionUtil.isNotEmpty(stdFunctionList)) {
|
for(String input : stdFunctionList){
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(input);
|
List<String> valueList = new ArrayList<String>();
|
addMatcherGroup(valueList, valueMatcher);
|
// STD函数里面至少有一个参数项
|
if (CollectionUtil.isEmpty(valueList)) {
|
throw new RuntimeException("公式不规范，STD函数里面至少有一个参数项：" + input);
|
}
|
|
String param = valueList.get(0);
|
for (ReportSampleItemDTO itemDTO : reportSampleItemList) {
|
String coed = "V[" + itemDTO.getItemCode() + "]";
|
if (coed.equals(param)) {
|
// 如果检测项值为数字类型直接替换，文字类型则增加单引号
|
if (NumberUtils.isCreatable(itemDTO.getItemValue())) {
|
judgeFormula = judgeFormula.replace(input, itemDTO.getItemReference());
|
} else {
|
judgeFormula = judgeFormula.replace(input, "'" + itemDTO.getItemReference() + "'");
|
}
|
break;
|
}
|
}
|
}
|
}
|
return judgeFormula;
|
}
|
|
|
/**
|
* 替换值-普通参数项
|
*
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
public static String replaceValue(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
// 将公式里的剩下的code替换为值
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
String coed = "V[" + reportSampleItem.getItemCode() + "]";
|
if (judgeFormula.contains(coed)) {
|
if (StringUtils.isBlank(reportSampleItem.getItemValue())) {
|
//throw new RuntimeException("检测项编号为" + reportSampleItem.getItemCode() + "参与计算的检测项值不能为空");
|
throw new RuntimeException("检测项编号=" + reportSampleItem.getItemCode() + "->检测值为空->公式无法引用");
|
} else {
|
// 如果检测项值为数字类型直接替换，文字类型则增加单引号
|
if (NumberUtils.isNumber(reportSampleItem.getItemValue())) {
|
judgeFormula = judgeFormula.replace(coed, reportSampleItem.getItemValue());
|
} else {
|
judgeFormula = judgeFormula.replace(coed, "'" + reportSampleItem.getItemValue() + "'");
|
}
|
}
|
}
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换值-合格函数
|
*
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
public static String replacePassFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher passMatcher = FunctionConfig.PATTEN_PASS.matcher(judgeFormula);
|
List<String> passFunctionList = new ArrayList<String>();
|
addMatcherGroup(passFunctionList, passMatcher);
|
if (CollectionUtil.isNotEmpty(passFunctionList)) {
|
for (int i = 0; i < passFunctionList.size(); i++) {
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(passFunctionList.get(i));
|
List<String> valueList = new ArrayList<String>();
|
addMatcherGroup(valueList, valueMatcher);
|
// 合格函数里面只能有一个参数项
|
if (CollectionUtil.isNotEmpty(valueList) && valueList.size() == 1) {
|
} else {
|
throw new RuntimeException("公式不规范，合格函数里面只能有一个参数项：" + passFunctionList.get(i));
|
}
|
}
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
judgeFormula = replaceWildcardCharacter(judgeFormula, reportSampleItem.getItemCode());
|
// 根据 pass 空格 （ 空格 函数通配符 空格） 去匹配，防止有空格
|
String coedPatten = "\\b(pass)\\s*\\(\\s*(" + FunctionConfig.WILDCARD_CHARACTER + ")?\\s*\\)";
|
Matcher passCodeMatcher = Pattern.compile(coedPatten).matcher(judgeFormula);
|
List<String> passCodeList = new ArrayList<String>();
|
addMatcherGroup(passCodeList, passCodeMatcher);
|
if (CollectionUtil.isNotEmpty(passCodeList)) {
|
if (reportSampleItem.getIsQualified() == null) {
|
throw new RuntimeException("参与合格函数计算的检测项合格状态不能为空：" + reportSampleItem.getItemName());
|
} else {
|
for (int i = 0; i < passCodeList.size(); i++) {
|
judgeFormula = judgeFormula.replace(passCodeList.get(i), reportSampleItem.getIsQualified().toString());
|
}
|
}
|
}
|
judgeFormula = reversalReplaceWildcardCharacter(judgeFormula, reportSampleItem.getItemCode());
|
}
|
}
|
// 这边再判断比对一下，预防不规范的写法
|
passMatcher = FunctionConfig.PATTEN_PASS.matcher(judgeFormula);
|
passFunctionList = new ArrayList<String>();
|
addMatcherGroup(passFunctionList, passMatcher);
|
if (CollectionUtil.isNotEmpty(passFunctionList)) {
|
throw new RuntimeException("公式存在无法处理的合格函数：" + judgeFormula);
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换值-平均值函数
|
*
|
* @param judgeFormula 需要替换的公式
|
* @param reportSampleItemList 检测项目值
|
* @return
|
*/
|
public static String replaceAvgFunction(String judgeFormula, List<ReportSampleItemDTO> reportSampleItemList) {
|
Matcher avgMatcher = FunctionConfig.PATTEN_AVG.matcher(judgeFormula);
|
List<String> avgFunctionList = new ArrayList<String>();
|
addMatcherGroup(avgFunctionList, avgMatcher);
|
if (CollectionUtil.isNotEmpty(avgFunctionList)) {
|
for (int i = 0; i < avgFunctionList.size(); i++) {
|
Matcher valueMatcher = FunctionConfig.PATTEN_VALUE.matcher(avgFunctionList.get(i));
|
List<String> valueList = new ArrayList<String>();
|
addMatcherGroup(valueList, valueMatcher);
|
// 平均值函数里面至少有一个参数项
|
if (CollectionUtil.isEmpty(valueList)) {
|
throw new RuntimeException("公式不规范，平均值函数里面至少有一个参数项：" + avgFunctionList.get(i));
|
}
|
// 处理平均值函数，然后直接替换公式
|
List<String> avgItemList = new ArrayList<String>();
|
for (int j = 0; j < valueList.size(); j++) {
|
for (ReportSampleItem reportSampleItem : reportSampleItemList) {
|
String coed = "V[" + reportSampleItem.getItemCode() + "]";
|
if (valueList.get(j).contains(coed)) {
|
// 平均值函数，几个参数有值，就按几个去计算
|
if (StringUtils.isNotBlank(reportSampleItem.getItemValue())) {
|
avgItemList.add(reportSampleItem.getItemValue());
|
}
|
break;
|
}
|
}
|
}
|
|
String replacement = "";
|
if (CollectionUtil.isNotEmpty(avgItemList)) {
|
replacement = "(" + avgItemList.stream().collect(Collectors.joining("+")) + ")/" + avgItemList.size();
|
} else {
|
replacement = "0";
|
}
|
judgeFormula = judgeFormula.replace(avgFunctionList.get(i), replacement);
|
}
|
}
|
// 这边再判断比对一下，预防不规范的写法
|
avgMatcher = FunctionConfig.PATTEN_AVG.matcher(judgeFormula);
|
avgFunctionList = new ArrayList<String>();
|
addMatcherGroup(avgFunctionList, avgMatcher);
|
if (CollectionUtil.isNotEmpty(avgFunctionList)) {
|
throw new RuntimeException("公式存在无法处理的平均值函数：" + judgeFormula);
|
}
|
return judgeFormula;
|
}
|
|
/**
|
* 替换通配符
|
*
|
* @param judgeFormula
|
* @param itemCode
|
* @return
|
*/
|
public static String replaceWildcardCharacter(String judgeFormula, String itemCode) {
|
// V[检测项编号]先用通配符转一下，要不然自定义的检测项编号在下面正则匹配公式一直报错
|
return judgeFormula.replace("V[" + itemCode + "]", FunctionConfig.WILDCARD_CHARACTER);
|
}
|
|
/**
|
* 替换通配符(反向)
|
*
|
* @param judgeFormula
|
* @param itemCode
|
* @return
|
*/
|
public static String reversalReplaceWildcardCharacter(String judgeFormula, String itemCode) {
|
return judgeFormula.replace(FunctionConfig.WILDCARD_CHARACTER, "V[" + itemCode + "]");
|
}
|
|
/**
|
* 把正则匹配出来的字符串保存到list
|
*
|
* @param list
|
* @param matcher
|
*/
|
public static void addMatcherGroup(List<String> list, Matcher matcher) {
|
while (matcher.find()) {
|
list.add(matcher.group());
|
}
|
}
|
|
/**
|
* 替换判定公式及计算公式中的参数code（重要前提：相同的原始code，不可能出现一个有线芯，一个没有线芯）
|
* @param testStandardParamList 操作对象
|
* @param newCode 新的code
|
* @param oldCode 旧的code
|
*/
|
public static void replaceFormulaParam(List<TestStandardParam> testStandardParamList, String newCode, String oldCode) {
|
for(TestStandardParam testStandardParam : testStandardParamList){
|
//如果公式字段中有值，则替换
|
if(StringUtils.isNotBlank(testStandardParam.getJudgeFormula())){
|
//判断公式
|
testStandardParam.setJudgeFormula(testStandardParam.getJudgeFormula().replace(oldCode,newCode));
|
}
|
if(StringUtils.isNotBlank(testStandardParam.getValueFormula())){
|
//值计算公式
|
testStandardParam.setValueFormula(testStandardParam.getValueFormula().replace(oldCode,newCode));
|
}
|
}
|
}
|
|
/**
|
* 对数换底公式计算
|
* @param base 底数
|
* @param value 值
|
* @return
|
*/
|
public static double log(double base, double value) {
|
return Math.log(value) / Math.log(base);
|
}
|
|
}
|
