package com.ruoyi.quality.util;
|
|
import com.ruoyi.quality.pojo.QualityInspectParam;
|
import org.apache.commons.lang3.StringUtils;
|
|
import java.math.BigDecimal;
|
import java.util.List;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
/**
|
* 检验值与标准/内控范围校验。
|
* 支持区间、正负偏差、大小比较和精确数值，例如：1.95~2.05、2.00±0.10、≤0.02、≥100。
|
*/
|
public final class QualityInspectionValueValidator {
|
|
private static final String NUMBER = "(-?\\d+(?:\\.\\d+)?)";
|
private static final Pattern RANGE = Pattern.compile("^" + NUMBER + "(?:~|～|至|—|-)" + NUMBER + "$");
|
private static final Pattern PLUS_MINUS = Pattern.compile("^" + NUMBER + "(?:±|\\+/-)" + NUMBER + "$");
|
private static final Pattern TOLERANCE_ONLY = Pattern.compile("^(?:±|\\+/-)" + NUMBER + "$");
|
private static final Pattern COMPARE = Pattern.compile("^(<=|>=|<|>|≤|≥)" + NUMBER + "$");
|
private static final Pattern EXACT = Pattern.compile("^" + NUMBER + "$");
|
private static final Pattern OBVIOUS_ABNORMAL_TEXT = Pattern.compile(".*(异常|不合格|失败|不通过|超标|缺陷).*", Pattern.CASE_INSENSITIVE);
|
|
private QualityInspectionValueValidator() {
|
}
|
|
public static String validateQualified(List<QualityInspectParam> parameters) {
|
if (parameters == null) {
|
return null;
|
}
|
for (QualityInspectParam parameter : parameters) {
|
String message = validateParameter(parameter);
|
if (message != null) {
|
return message;
|
}
|
}
|
return null;
|
}
|
|
private static String validateParameter(QualityInspectParam parameter) {
|
if (parameter == null || StringUtils.isBlank(parameter.getTestValue())) {
|
return null;
|
}
|
String testText = normalize(parameter.getTestValue());
|
if (OBVIOUS_ABNORMAL_TEXT.matcher(testText).matches()) {
|
return error(parameter, effectiveRule(parameter));
|
}
|
|
BigDecimal testValue = decimal(testText);
|
String rule = firstNumericRule(parameter.getControlValue(), parameter.getStandardValue());
|
if (rule == null) {
|
return null;
|
}
|
if (testValue == null || !matches(testValue, rule)) {
|
return error(parameter, rule);
|
}
|
return null;
|
}
|
|
private static String firstNumericRule(String controlValue, String standardValue) {
|
String control = normalize(controlValue);
|
if (isSupportedRule(control)) {
|
return control;
|
}
|
String standard = normalize(standardValue);
|
return isSupportedRule(standard) ? standard : null;
|
}
|
|
private static boolean isSupportedRule(String rule) {
|
return rule != null && (RANGE.matcher(rule).matches()
|
|| PLUS_MINUS.matcher(rule).matches()
|
|| TOLERANCE_ONLY.matcher(rule).matches()
|
|| COMPARE.matcher(rule).matches()
|
|| EXACT.matcher(rule).matches());
|
}
|
|
private static boolean matches(BigDecimal value, String rule) {
|
Matcher matcher = RANGE.matcher(rule);
|
if (matcher.matches()) {
|
BigDecimal first = new BigDecimal(matcher.group(1));
|
BigDecimal second = new BigDecimal(matcher.group(2));
|
BigDecimal min = first.min(second);
|
BigDecimal max = first.max(second);
|
return value.compareTo(min) >= 0 && value.compareTo(max) <= 0;
|
}
|
matcher = PLUS_MINUS.matcher(rule);
|
if (matcher.matches()) {
|
BigDecimal center = new BigDecimal(matcher.group(1));
|
BigDecimal tolerance = new BigDecimal(matcher.group(2)).abs();
|
return value.compareTo(center.subtract(tolerance)) >= 0
|
&& value.compareTo(center.add(tolerance)) <= 0;
|
}
|
Matcher toleranceOnly = TOLERANCE_ONLY.matcher(rule);
|
if (toleranceOnly.matches()) {
|
BigDecimal tolerance = new BigDecimal(toleranceOnly.group(1)).abs();
|
return value.abs().compareTo(tolerance) <= 0;
|
}
|
matcher = COMPARE.matcher(rule);
|
if (matcher.matches()) {
|
int compared = value.compareTo(new BigDecimal(matcher.group(2)));
|
String operator = matcher.group(1);
|
if ("<".equals(operator)) return compared < 0;
|
if (">".equals(operator)) return compared > 0;
|
if ("<=".equals(operator) || "≤".equals(operator)) return compared <= 0;
|
return compared >= 0;
|
}
|
matcher = EXACT.matcher(rule);
|
return matcher.matches() && value.compareTo(new BigDecimal(matcher.group(1))) == 0;
|
}
|
|
private static BigDecimal decimal(String value) {
|
try {
|
return StringUtils.isBlank(value) ? null : new BigDecimal(value);
|
} catch (NumberFormatException ignored) {
|
return null;
|
}
|
}
|
|
private static String normalize(String value) {
|
return StringUtils.isBlank(value) ? null : value.trim().replaceAll("\\s+", "").replace(",", "");
|
}
|
|
private static String effectiveRule(QualityInspectParam parameter) {
|
return StringUtils.isNotBlank(parameter.getControlValue())
|
? parameter.getControlValue() : parameter.getStandardValue();
|
}
|
|
private static String error(QualityInspectParam parameter, String rule) {
|
String item = StringUtils.defaultIfBlank(parameter.getParameterItem(), "未命名指标");
|
String standard = StringUtils.defaultIfBlank(rule, "已配置标准");
|
return "检验项目“" + item + "”的检验值“" + parameter.getTestValue()
|
+ "”不符合标准（" + standard + "），不能按合格保存";
|
}
|
}
|
