package jnpf.elnService.formula.impl;
|
|
import jnpf.elnFormula.FormulaAst;
|
import jnpf.elnFormula.FormulaDiagnostic;
|
import jnpf.elnFormula.FormulaException;
|
import jnpf.elnFormula.FormulaFunctionRegistry;
|
import jnpf.elnFormula.FormulaLatexRenderer;
|
import jnpf.elnFormula.FormulaLimits;
|
import jnpf.elnFormula.FormulaParser;
|
import jnpf.elnFormula.FormulaType;
|
import jnpf.elnFormula.FormulaTypeChecker;
|
import jnpf.elnService.formula.FormulaValidationService;
|
import org.springframework.stereotype.Service;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashSet;
|
import java.util.LinkedHashMap;
|
import java.util.List;
|
import java.util.Locale;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.regex.Pattern;
|
|
@Service
|
public class FormulaValidationServiceImpl implements FormulaValidationService {
|
|
private static final Pattern PARAMETER_CODE = Pattern.compile("[a-z][a-z0-9_]*");
|
private static final Set<String> ROUNDING_MODES = new HashSet<>(
|
Arrays.asList("HALF_UP", "HALF_EVEN", "UP", "DOWN"));
|
|
private final FormulaParser parser;
|
private final FormulaFunctionRegistry functions;
|
private final FormulaTypeChecker typeChecker;
|
private final FormulaLatexRenderer latexRenderer;
|
|
public FormulaValidationServiceImpl() {
|
this.parser = new FormulaParser();
|
this.functions = new FormulaFunctionRegistry();
|
this.typeChecker = new FormulaTypeChecker(functions);
|
this.latexRenderer = new FormulaLatexRenderer();
|
}
|
|
@Override
|
public ValidationResult validate(FormulaValidationRequest request) {
|
List<FormulaDiagnostic> diagnostics = new ArrayList<>();
|
validateInput(request, diagnostics);
|
if (hasErrors(diagnostics)) {
|
return result(diagnostics, null, null);
|
}
|
|
FormulaAst.Node ast;
|
try {
|
ast = parser.parse(request.getExpression());
|
} catch (FormulaParser.ParseException ex) {
|
diagnostics.add(error(ex.getCode(), ex.getMessage(),
|
ex.getStartOffset(), ex.getEndOffset()));
|
return result(diagnostics, null, null);
|
}
|
|
Map<String, FormulaType> parameterTypes = new LinkedHashMap<>();
|
Map<String, String> parameterNames = new LinkedHashMap<>();
|
for (ParameterSlot slot : request.getParameters()) {
|
parameterTypes.put(slot.getCode(), slot.getType());
|
parameterNames.put(slot.getCode(), slot.getDisplayName());
|
if (functions.contains(slot.getCode().toUpperCase(Locale.ROOT))) {
|
diagnostics.add(error("PARAMETER_FUNCTION_NAME_CONFLICT",
|
"参数编码与函数名冲突: " + slot.getCode(), -1, -1));
|
}
|
}
|
|
Set<String> usedParameters = new HashSet<>();
|
collectParameters(ast, usedParameters, diagnostics, parameterTypes);
|
for (ParameterSlot slot : request.getParameters()) {
|
if (!usedParameters.contains(slot.getCode())) {
|
diagnostics.add(warning("UNUSED_PARAMETER",
|
"参数未在公式中使用: " + slot.getCode(), -1, -1));
|
}
|
}
|
if (hasErrors(diagnostics)) {
|
return result(diagnostics, null, null);
|
}
|
|
validateFunctionSignatures(ast, diagnostics);
|
if (hasErrors(diagnostics)) {
|
return result(diagnostics, null, null);
|
}
|
|
FormulaType inferredType;
|
try {
|
inferredType = typeChecker.check(ast, parameterTypes);
|
} catch (FormulaException ex) {
|
diagnostics.add(error(ex.getCode(), ex.getMessage(),
|
ex.getStartOffset(), ex.getEndOffset()));
|
return result(diagnostics, null, null);
|
}
|
|
if (inferredType != request.getResultType()) {
|
diagnostics.add(error("RESULT_TYPE_MISMATCH",
|
"公式结果类型与声明类型不一致", ast.getStartOffset(), ast.getEndOffset()));
|
return result(diagnostics, null, inferredType);
|
}
|
|
validateRounding(request, diagnostics);
|
if (hasErrors(diagnostics)) {
|
return result(diagnostics, null, inferredType);
|
}
|
|
return result(diagnostics, latexRenderer.render(ast, parameterNames), inferredType);
|
}
|
|
private static void validateInput(FormulaValidationRequest request,
|
List<FormulaDiagnostic> diagnostics) {
|
if (request == null) {
|
diagnostics.add(error("INVALID_REQUEST", "验证请求不能为空", -1, -1));
|
return;
|
}
|
String expression = request.getExpression();
|
if (expression == null || expression.trim().isEmpty()) {
|
diagnostics.add(error("EXPRESSION_REQUIRED", "公式不能为空", 0,
|
expression == null ? 0 : expression.length()));
|
}
|
List<ParameterSlot> parameters = request.getParameters();
|
if (parameters == null) {
|
diagnostics.add(error("PARAMETERS_REQUIRED", "参数列表不能为空", -1, -1));
|
} else {
|
Set<String> codes = new HashSet<>();
|
for (ParameterSlot slot : parameters) {
|
if (slot == null) {
|
diagnostics.add(error("INVALID_PARAMETER", "参数项不能为空", -1, -1));
|
continue;
|
}
|
if (slot.getCode() == null || !PARAMETER_CODE.matcher(slot.getCode()).matches()) {
|
diagnostics.add(error("INVALID_PARAMETER_CODE", "参数编码格式不正确", -1, -1));
|
} else {
|
if (FormulaParser.isReservedParameterCode(slot.getCode())) {
|
diagnostics.add(error("RESERVED_PARAMETER_CODE", "参数编码为公式保留字: "
|
+ slot.getCode(), -1, -1));
|
}
|
if (!codes.add(slot.getCode())) {
|
diagnostics.add(error("DUPLICATE_PARAMETER", "参数编码重复: "
|
+ slot.getCode(), -1, -1));
|
}
|
}
|
if (slot.getDisplayName() == null || slot.getDisplayName().trim().isEmpty()) {
|
diagnostics.add(error("INVALID_PARAMETER_DISPLAY_NAME", "参数显示名不能为空", -1, -1));
|
}
|
if (slot.getType() == null || slot.getType() == FormulaType.NULL) {
|
diagnostics.add(error("INVALID_PARAMETER_TYPE", "参数类型不合法", -1, -1));
|
}
|
}
|
}
|
FormulaType resultType = request.getResultType();
|
if (resultType != FormulaType.DECIMAL && resultType != FormulaType.TEXT
|
&& resultType != FormulaType.BOOLEAN) {
|
diagnostics.add(error("INVALID_RESULT_TYPE", "声明结果类型不合法", -1, -1));
|
}
|
}
|
|
private static void validateRounding(FormulaValidationRequest request,
|
List<FormulaDiagnostic> diagnostics) {
|
Integer scale = request.getRoundScale();
|
String mode = request.getRoundMode();
|
if ((scale == null) != (mode == null)) {
|
diagnostics.add(error("INVALID_ROUNDING_CONFIGURATION", "修约位数和模式必须同时提供", -1, -1));
|
return;
|
}
|
if (scale == null) {
|
return;
|
}
|
if (scale < 0 || scale > 12) {
|
diagnostics.add(error("INVALID_ROUNDING_SCALE", "修约位数必须在 0 到 12 之间", -1, -1));
|
}
|
if (!ROUNDING_MODES.contains(mode)) {
|
diagnostics.add(error("UNSUPPORTED_ROUNDING_MODE", "不支持的修约模式", -1, -1));
|
}
|
if (request.getResultType() != FormulaType.DECIMAL) {
|
diagnostics.add(error("ROUNDING_NOT_ALLOWED", "仅数值结果允许配置修约", -1, -1));
|
}
|
}
|
|
private static void collectParameters(FormulaAst.Node node, Set<String> used,
|
List<FormulaDiagnostic> diagnostics,
|
Map<String, FormulaType> declared) {
|
if (node instanceof FormulaAst.Parameter) {
|
FormulaAst.Parameter parameter = (FormulaAst.Parameter) node;
|
used.add(parameter.getCode());
|
if (!declared.containsKey(parameter.getCode())) {
|
diagnostics.add(error("UNKNOWN_PARAMETER", "未知参数: " + parameter.getCode(),
|
parameter.getStartOffset(), parameter.getEndOffset()));
|
}
|
return;
|
}
|
if (node instanceof FormulaAst.Unary) {
|
collectParameters(((FormulaAst.Unary) node).getOperand(), used, diagnostics, declared);
|
} else if (node instanceof FormulaAst.Binary) {
|
FormulaAst.Binary binary = (FormulaAst.Binary) node;
|
collectParameters(binary.getLeft(), used, diagnostics, declared);
|
collectParameters(binary.getRight(), used, diagnostics, declared);
|
} else if (node instanceof FormulaAst.FunctionCall) {
|
for (FormulaAst.Node argument : ((FormulaAst.FunctionCall) node).getArguments()) {
|
collectParameters(argument, used, diagnostics, declared);
|
}
|
}
|
}
|
|
private void validateFunctionSignatures(FormulaAst.Node node,
|
List<FormulaDiagnostic> diagnostics) {
|
if (node instanceof FormulaAst.FunctionCall) {
|
FormulaAst.FunctionCall call = (FormulaAst.FunctionCall) node;
|
String name = call.getName();
|
int count = call.getArguments().size();
|
if (!functions.contains(name)) {
|
diagnostics.add(error("UNKNOWN_FUNCTION", "未知函数: " + name,
|
call.getStartOffset(), call.getEndOffset()));
|
return;
|
}
|
if (!validArgumentCount(name, count)) {
|
diagnostics.add(error("FUNCTION_ARGUMENT_COUNT_MISMATCH", "函数参数数量不正确",
|
call.getStartOffset(), call.getEndOffset()));
|
return;
|
}
|
for (FormulaAst.Node argument : call.getArguments()) {
|
validateFunctionSignatures(argument, diagnostics);
|
if (hasErrors(diagnostics)) {
|
return;
|
}
|
}
|
} else if (node instanceof FormulaAst.Unary) {
|
validateFunctionSignatures(((FormulaAst.Unary) node).getOperand(), diagnostics);
|
} else if (node instanceof FormulaAst.Binary) {
|
FormulaAst.Binary binary = (FormulaAst.Binary) node;
|
validateFunctionSignatures(binary.getLeft(), diagnostics);
|
if (!hasErrors(diagnostics)) {
|
validateFunctionSignatures(binary.getRight(), diagnostics);
|
}
|
}
|
}
|
|
private static boolean validArgumentCount(String name, int count) {
|
if ("ABS".equals(name) || "SQRT".equals(name) || "IS_BLANK".equals(name)
|
|| "LN".equals(name) || "LOG10".equals(name) || "EXP".equals(name)
|
|| "SUM".equals(name) || "MEAN".equals(name) || "STDDEV_S".equals(name)
|
|| "STDDEV_P".equals(name) || "VAR_S".equals(name)
|
|| "VAR_P".equals(name) || "RSD".equals(name)
|
|| "COUNT".equals(name) || "MEDIAN".equals(name)
|
|| "GEOMEAN".equals(name)) {
|
return count == 1;
|
}
|
if ("POW".equals(name) || "LOG".equals(name) || "NTH_ROOT".equals(name)
|
|| "WEIGHTED_MEAN".equals(name) || "SLOPE".equals(name)
|
|| "INTERCEPT".equals(name) || "CORREL".equals(name)
|
|| "ROUND".equals(name) || "ROUND_UP".equals(name)
|
|| "ROUND_DOWN".equals(name) || "ROUND_HALF_EVEN".equals(name)
|
|| "ROUND_SIG".equals(name) || "ROUND_SIG_HALF_EVEN".equals(name)) {
|
return count == 2;
|
}
|
if ("IF".equals(name) || "CONVERT".equals(name)
|
|| "LINEAR_PREDICT".equals(name)) {
|
return count == 3;
|
}
|
if ("MIN".equals(name) || "MAX".equals(name) || "COALESCE".equals(name)) {
|
return count >= 1 && count <= FormulaLimits.DEFAULTS.getMaxFunctionArguments();
|
}
|
if ("LOOKUP_EXACT".equals(name)) {
|
return count >= 3 && count % 2 == 1;
|
}
|
if ("LOOKUP_LINEAR".equals(name)) {
|
return count >= 5 && count % 2 == 1;
|
}
|
return false;
|
}
|
|
private static ValidationResult result(List<FormulaDiagnostic> diagnostics,
|
String latex, FormulaType inferredType) {
|
return new ValidationResult(diagnostics, latex, inferredType);
|
}
|
|
private static boolean hasErrors(List<FormulaDiagnostic> diagnostics) {
|
for (FormulaDiagnostic diagnostic : diagnostics) {
|
if (diagnostic.getSeverity() == FormulaDiagnostic.Severity.ERROR) {
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private static FormulaDiagnostic error(String code, String message, int start, int end) {
|
return new FormulaDiagnostic(FormulaDiagnostic.Severity.ERROR, code, message, start, end);
|
}
|
|
private static FormulaDiagnostic warning(String code, String message, int start, int end) {
|
return new FormulaDiagnostic(FormulaDiagnostic.Severity.WARNING, code, message, start, end);
|
}
|
}
|
