package cn.iocoder.yudao.module.qcreport.engine.rule;
|
|
import cn.iocoder.yudao.module.qcreport.engine.JsValues;
|
import cn.iocoder.yudao.module.qcreport.engine.Paths;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
|
/**
|
* 规则求值。
|
* <p>
|
* 只认 {@link RuleNode} 与白名单函数，规则文本里的任何内容都不会变成可执行代码。
|
* 与前端 {@code engine/rule-engine.ts} 的求值段一一对应，两边结果必须一致。
|
*/
|
public final class RuleEvaluator {
|
|
/** 判定结果类取值统一成 PASS / FAIL：兼容中文、布尔与数字 1/0 */
|
private static final Set<String> PASS_TOKENS = Set.of("PASS", "TRUE", "合格", "OK", "1", "是");
|
private static final Set<String> FAIL_TOKENS = Set.of("FAIL", "FALSE", "不合格", "NG", "0", "否");
|
|
private RuleEvaluator() {
|
}
|
|
/* ------------------------------ 基础判定 ------------------------------ */
|
|
/**
|
* JS {@code String(value)} 的等价实现。
|
* <p>
|
* 规则里的文本比较与拼接都要走这里，否则两端会算出不同结果。
|
*/
|
public static String asText(Object value) {
|
return JsValues.asText(value);
|
}
|
|
/** 空值：null 或空串（空数组不算空） */
|
public static boolean isBlank(Object value) {
|
return value == null || "".equals(value);
|
}
|
|
/** 真值判定，与 JS 版 truthy 同语义 */
|
public static boolean truthy(Object value) {
|
if (value instanceof List<?> list) {
|
return !list.isEmpty();
|
}
|
if (isBlank(value)) {
|
return false;
|
}
|
if (value instanceof Boolean bool) {
|
return bool;
|
}
|
double numeric = Paths.toNumber(value);
|
if (Double.isFinite(numeric)) {
|
return numeric != 0;
|
}
|
return true;
|
}
|
|
/** 两侧都能当数字时按数值比较，否则按字符串比较 */
|
public static int compare(Object left, Object right) {
|
double leftNumber = Paths.toNumber(left);
|
double rightNumber = Paths.toNumber(right);
|
if (Double.isFinite(leftNumber) && Double.isFinite(rightNumber)) {
|
return Double.compare(leftNumber, rightNumber);
|
}
|
return asText(left).compareTo(asText(right));
|
}
|
|
/** 判定结果类取值统一成 PASS / FAIL，识别不出返回空串 */
|
public static String normalizeResultToken(Object value) {
|
if (value instanceof Boolean bool) {
|
return bool ? "PASS" : "FAIL";
|
}
|
String text = asText(value).trim().toUpperCase(Locale.ROOT);
|
if (PASS_TOKENS.contains(text)) {
|
return "PASS";
|
}
|
return FAIL_TOKENS.contains(text) ? "FAIL" : "";
|
}
|
|
/* ------------------------------ 白名单函数 ------------------------------ */
|
|
/** 白名单函数表，规则文本只能调用这里面的函数 */
|
private static final Map<String, RuleFunction> FUNCTIONS = buildFunctions();
|
|
private static Map<String, RuleFunction> buildFunctions() {
|
Map<String, RuleFunction> functions = new LinkedHashMap<>();
|
functions.put("ABS", args -> Math.abs(requireNumber("ABS", arg(args, 0))));
|
functions.put("AVG", args -> mean(requireNumbers("AVG", arg(args, 0))));
|
functions.put("COUNT", args -> arg(args, 0) instanceof List<?> list
|
? list.size()
|
: Paths.toNumberArray(arg(args, 0)).size());
|
// 过程能力指数 CP=(USL-LSL)/(6σ)
|
functions.put("CP", args -> {
|
List<Double> values = requireNumbers("CP", arg(args, 0));
|
double deviation = standardDeviation(values);
|
if (!Double.isFinite(deviation) || deviation == 0) {
|
return Double.NaN;
|
}
|
return (requireNumber("CP", arg(args, 1)) - requireNumber("CP", arg(args, 2))) / (6 * deviation);
|
});
|
// 过程能力指数 CPK=min(USL-μ, μ-LSL)/(3σ)
|
functions.put("CPK", args -> {
|
List<Double> values = requireNumbers("CPK", arg(args, 0));
|
double deviation = standardDeviation(values);
|
if (!Double.isFinite(deviation) || deviation == 0) {
|
return Double.NaN;
|
}
|
double upper = requireNumber("CPK", arg(args, 1));
|
double lower = requireNumber("CPK", arg(args, 2));
|
double average = mean(values);
|
return Math.min(upper - average, average - lower) / (3 * deviation);
|
});
|
// 不合格率（百分比），口径与 PASS_RATE 一致
|
functions.put("FAIL_RATE", args -> rate(arg(args, 0), "FAIL"));
|
functions.put("MAX", args -> extreme(requireNumbers("MAX", arg(args, 0)), true));
|
functions.put("MIN", args -> extreme(requireNumbers("MIN", arg(args, 0)), false));
|
// 合格率（百分比，保留两位）
|
functions.put("PASS_RATE", args -> rate(arg(args, 0), "PASS"));
|
functions.put("ROUND", args -> {
|
double digits = args.size() > 1 ? requireNumber("ROUND", arg(args, 1)) : 0;
|
double factor = Math.pow(10, digits);
|
return Math.round(requireNumber("ROUND", arg(args, 0)) * factor) / factor;
|
});
|
functions.put("STDDEV", args -> standardDeviation(requireNumbers("STDDEV", arg(args, 0))));
|
functions.put("SUM", args -> {
|
double sum = 0;
|
for (Double value : requireNumbers("SUM", arg(args, 0))) {
|
sum += value;
|
}
|
return sum;
|
});
|
// 不能换成 Map.copyOf：它不保证遍历顺序，报错里列出的可用函数会随机排
|
return Collections.unmodifiableMap(functions);
|
}
|
|
/**
|
* 取第 index 个实参，缺参返回 null。
|
* <p>
|
* 少了这个兜底，{@code SUM()} 这种写错的规则会直接抛 IndexOutOfBoundsException 穿透到接口层，
|
* 用户看到的是「系统异常」而不是「这条规则写错了」。
|
*/
|
private static Object arg(List<Object> args, int index) {
|
return index < args.size() ? args.get(index) : null;
|
}
|
|
/** 白名单函数名，顺序稳定，用于报错时列出可用函数 */
|
public static List<String> functionNames() {
|
return List.copyOf(FUNCTIONS.keySet());
|
}
|
|
/** 一次性求值全部合格/不合格占比，口径与前端一致 */
|
private static double rate(Object value, String expected) {
|
List<Object> values = Paths.flatten(value);
|
if (values.isEmpty()) {
|
return Double.NaN;
|
}
|
int hit = 0;
|
for (Object element : values) {
|
if (expected.equals(normalizeResultToken(element))) {
|
hit++;
|
}
|
}
|
return toFixed2((double) hit / values.size() * 100);
|
}
|
|
/** JS toFixed(2) 后再取回数值：保留两位的百分比 */
|
private static double toFixed2(double value) {
|
return Math.round(value * 100) / 100.0;
|
}
|
|
private static double extreme(List<Double> values, boolean max) {
|
double result = values.get(0);
|
for (Double value : values) {
|
result = max ? Math.max(result, value) : Math.min(result, value);
|
}
|
return result;
|
}
|
|
private static double mean(List<Double> values) {
|
double sum = 0;
|
for (Double value : values) {
|
sum += value;
|
}
|
return sum / values.size();
|
}
|
|
/** 样本标准差（n-1），SPC 计算 CP/CPK 用这个口径 */
|
private static double standardDeviation(List<Double> values) {
|
if (values.size() < 2) {
|
return Double.NaN;
|
}
|
double average = mean(values);
|
double variance = 0;
|
for (Double value : values) {
|
variance += Math.pow(value - average, 2);
|
}
|
return Math.sqrt(variance / (values.size() - 1));
|
}
|
|
private static List<Double> requireNumbers(String name, Object value) {
|
List<Double> values = Paths.toNumberArray(value);
|
if (values.isEmpty()) {
|
throw new RuleRuntimeException("函数 " + name + " 需要数值型参数，实际取到「" + asText(value) + "」");
|
}
|
return values;
|
}
|
|
private static double requireNumber(String name, Object value) {
|
double numeric = Paths.toNumber(value);
|
if (!Double.isFinite(numeric)) {
|
throw new RuleRuntimeException("函数 " + name + " 需要数字参数，实际取到「" + asText(value) + "」");
|
}
|
return numeric;
|
}
|
|
/* ------------------------------ 求值 ------------------------------ */
|
|
/** 求值，返回原始结果（可能是数字、字符串、布尔） */
|
public static Object evaluateNode(RuleNode node, Object context) {
|
return switch (node) {
|
case RuleNode.Literal literal -> literal.value();
|
case RuleNode.Path path -> Paths.readPath(context, path.path());
|
case RuleNode.Call call -> evaluateCall(call, context);
|
case RuleNode.Unary unary -> evaluateUnary(unary, context);
|
case RuleNode.Between between -> evaluateBetween(between, context);
|
case RuleNode.In inNode -> evaluateIn(inNode, context);
|
case RuleNode.Binary binary -> evaluateBinary(binary, context);
|
};
|
}
|
|
/** 求值并转成布尔判定，用于「是否合格」这类条件 */
|
public static boolean evaluateCondition(RuleNode node, Object context) {
|
return truthy(evaluateNode(node, context));
|
}
|
|
private static Object evaluateCall(RuleNode.Call call, Object context) {
|
RuleFunction handler = FUNCTIONS.get(call.name());
|
if (handler == null) {
|
throw new RuleRuntimeException(
|
"不支持函数 " + call.name() + "，可用函数：" + String.join("、", FUNCTIONS.keySet()));
|
}
|
List<Object> args = new ArrayList<>(call.args().size());
|
for (RuleNode arg : call.args()) {
|
args.add(evaluateNode(arg, context));
|
}
|
return handler.apply(args);
|
}
|
|
private static Object evaluateUnary(RuleNode.Unary unary, Object context) {
|
Object value = evaluateNode(unary.operand(), context);
|
return "!".equals(unary.operator()) ? !truthy(value) : -Paths.toNumber(value);
|
}
|
|
private static Object evaluateBetween(RuleNode.Between between, Object context) {
|
Object value = evaluateNode(between.value(), context);
|
boolean hit = compare(value, evaluateNode(between.lower(), context)) >= 0
|
&& compare(value, evaluateNode(between.upper(), context)) <= 0;
|
return between.negated() != hit;
|
}
|
|
private static Object evaluateIn(RuleNode.In inNode, Object context) {
|
Object value = evaluateNode(inNode.value(), context);
|
boolean hit = false;
|
for (RuleNode item : inNode.items()) {
|
if (compare(value, evaluateNode(item, context)) == 0) {
|
hit = true;
|
break;
|
}
|
}
|
return inNode.negated() != hit;
|
}
|
|
private static Object evaluateBinary(RuleNode.Binary binary, Object context) {
|
if ("AND".equals(binary.operator())) {
|
return truthy(evaluateNode(binary.left(), context)) && truthy(evaluateNode(binary.right(), context));
|
}
|
if ("OR".equals(binary.operator())) {
|
return truthy(evaluateNode(binary.left(), context)) || truthy(evaluateNode(binary.right(), context));
|
}
|
|
Object left = evaluateNode(binary.left(), context);
|
Object right = evaluateNode(binary.right(), context);
|
|
return switch (binary.operator()) {
|
case "=" -> compare(left, right) == 0;
|
case "!=" -> compare(left, right) != 0;
|
case ">" -> compare(left, right) > 0;
|
case ">=" -> compare(left, right) >= 0;
|
case "<" -> compare(left, right) < 0;
|
case "<=" -> compare(left, right) <= 0;
|
case "+" -> add(left, right);
|
case "-" -> Paths.toNumber(left) - Paths.toNumber(right);
|
case "*" -> Paths.toNumber(left) * Paths.toNumber(right);
|
case "/" -> divide(left, right);
|
default -> throw new RuleRuntimeException("不支持的运算符 " + binary.operator());
|
};
|
}
|
|
/** 两侧都是数值才做加法，否则按文本拼接（编号类字段常用） */
|
private static Object add(Object left, Object right) {
|
double leftNumber = Paths.toNumber(left);
|
double rightNumber = Paths.toNumber(right);
|
if (Double.isFinite(leftNumber) && Double.isFinite(rightNumber)) {
|
return leftNumber + rightNumber;
|
}
|
return asText(left) + asText(right);
|
}
|
|
private static Object divide(Object left, Object right) {
|
double divisor = Paths.toNumber(right);
|
if (divisor == 0) {
|
throw new RuleRuntimeException("规则里出现了除以 0");
|
}
|
return Paths.toNumber(left) / divisor;
|
}
|
|
/* ------------------------------ 静态分析 ------------------------------ */
|
|
/** 表达式里调用的函数名（含嵌套），用于保存前校验白名单 */
|
public static List<String> listFunctionNames(RuleNode node) {
|
List<String> names = new ArrayList<>();
|
collectFunctionNames(node, names);
|
return names;
|
}
|
|
private static void collectFunctionNames(RuleNode node, List<String> names) {
|
switch (node) {
|
case RuleNode.Call call -> {
|
names.add(call.name());
|
call.args().forEach(arg -> collectFunctionNames(arg, names));
|
}
|
case RuleNode.Unary unary -> collectFunctionNames(unary.operand(), names);
|
case RuleNode.Binary binary -> {
|
collectFunctionNames(binary.left(), names);
|
collectFunctionNames(binary.right(), names);
|
}
|
case RuleNode.Between between -> {
|
collectFunctionNames(between.value(), names);
|
collectFunctionNames(between.lower(), names);
|
collectFunctionNames(between.upper(), names);
|
}
|
case RuleNode.In inNode -> {
|
collectFunctionNames(inNode.value(), names);
|
inNode.items().forEach(item -> collectFunctionNames(item, names));
|
}
|
default -> {
|
}
|
}
|
}
|
|
/** 未知函数名返回 null，供调用方给出可读报错 */
|
public static String findUnknownFunction(RuleNode node) {
|
for (String name : listFunctionNames(node)) {
|
if (!FUNCTIONS.containsKey(name)) {
|
return name;
|
}
|
}
|
return null;
|
}
|
|
/**
|
* 解析后的路径依赖，渲染前可据此检查数据是否齐备。
|
* <p>
|
* 统计函数作用在数组路径上，这里去掉末端字段只保留数组本身。
|
*/
|
public static List<String> listPaths(RuleNode node) {
|
Set<String> paths = new LinkedHashSet<>();
|
collectPaths(node, paths);
|
Set<String> normalized = new LinkedHashSet<>();
|
for (String path : paths) {
|
normalized.add(String.join(".", Paths.parsePath(path)));
|
}
|
return List.copyOf(normalized);
|
}
|
|
private static void collectPaths(RuleNode node, Set<String> paths) {
|
switch (node) {
|
case RuleNode.Path path -> {
|
paths.add(path.path());
|
}
|
case RuleNode.Call call -> call.args().forEach(arg -> collectPaths(arg, paths));
|
case RuleNode.Unary unary -> collectPaths(unary.operand(), paths);
|
case RuleNode.Binary binary -> {
|
collectPaths(binary.left(), paths);
|
collectPaths(binary.right(), paths);
|
}
|
case RuleNode.Between between -> {
|
collectPaths(between.value(), paths);
|
collectPaths(between.lower(), paths);
|
collectPaths(between.upper(), paths);
|
}
|
case RuleNode.In inNode -> {
|
collectPaths(inNode.value(), paths);
|
inNode.items().forEach(item -> collectPaths(item, paths));
|
}
|
default -> {
|
}
|
}
|
}
|
|
/** 白名单函数 */
|
@FunctionalInterface
|
public interface RuleFunction {
|
|
Object apply(List<Object> args);
|
|
}
|
|
}
|
