package jnpf.limsService.support;
|
|
import java.io.IOException;
|
import java.nio.charset.StandardCharsets;
|
import java.nio.file.Files;
|
import java.nio.file.Path;
|
import java.nio.file.Paths;
|
import java.util.stream.Stream;
|
|
/** SIGN_USED 业务入口、模块语义和折叠接线的源码级回归探针。 */
|
public final class LimsSignUsageWiringProbe {
|
|
private static int passed;
|
private static int failed;
|
|
public static void main(String[] args) throws Exception {
|
String qingyandanController = read("jnpf-lims/jnpf-lims-controller/src/main/java/"
|
+ "jnpf/limsController/LimsQingyandanController.java");
|
String quyangController = read("jnpf-lims/jnpf-lims-controller/src/main/java/"
|
+ "jnpf/limsController/LimsQuyangController.java");
|
String jieyangController = read("jnpf-lims/jnpf-lims-controller/src/main/java/"
|
+ "jnpf/limsController/LimsJieyangController.java");
|
String huanjingController = read("jnpf-lims/jnpf-lims-controller/src/main/java/"
|
+ "jnpf/limsController/LimsHuanjingJianceController.java");
|
String qingyandanService = read("jnpf-lims/jnpf-lims-biz/src/main/java/"
|
+ "jnpf/limsService/impl/LimsQingyandanServiceImpl.java");
|
String signService = read("jnpf-lims/jnpf-lims-biz/src/main/java/"
|
+ "jnpf/limsService/impl/LimsSignServiceImpl.java");
|
String signOpType = read("jnpf-lims/jnpf-lims-entity/src/main/java/"
|
+ "jnpf/limsEntity/SignOpType.java");
|
String qingyandanEntity = read("jnpf-lims/jnpf-lims-entity/src/main/java/"
|
+ "jnpf/limsEntity/LimsQingyandanEntity.java");
|
|
// 2026-07-31 retarget（原为 checkConsumption("请验单提交", qingyandanController,
|
// "QINGYANDAN_SUBMIT")）：旧断言查「submit 之后调用了 recordSignUsage」，
|
// 而 D8 明确表单路径**停写事件、保留原子认领**。语义变了，判据跟着变；
|
// 认领这件事**必须继续有人守**（防重放护栏，删了同一签名可反复使用），故是 retarget 不是删除。
|
checkQingyandanSubmitClaim(qingyandanController);
|
checkQingyandanFreshSign(qingyandanController);
|
checkCancelConsumption(qingyandanController);
|
checkConsumption("取样", quyangController, "QUYANG_FETCH");
|
checkConsumption("接样", jieyangController, "JIEYANG_RECEIVE");
|
checkHuanjingFailureBoundary(huanjingController, "public R<String> quyangJilu(",
|
"limsHuanjingJianceService.quyangJilu", "HUANJING_QUYANG");
|
checkHuanjingFailureBoundary(huanjingController, "public R<String> terminateQuyangJilu(",
|
"limsHuanjingJianceService.terminateQuyangJilu", "HUANJING_QUYANG_TERMINATE");
|
|
// ┌─ 2026-07-31 删除，留痕如下（不是有人删断言换绿）────────────────────────────┐
|
// │ 曾经断言：check("请验单提交 Layer 2 与消费事件共事务", │
|
// │ annotatedBusinessAction(qingyandanService, │
|
// │ "action = \"SUBMIT\"", "public void submit("), │
|
// │ "submit 缺少 @AuditLog"); │
|
// │ 即：LimsQingyandanServiceImpl.submit() 必须带 @AuditLog(action="SUBMIT")。│
|
// │ │
|
// │ 为什么被取代：spec D7 已把两处 SUBMIT 埋点整块删除——客户关注的是他自己触发 │
|
// │ 的动作（表单的新增/修改），那已由层 0 记录；submit() 是表单保存之后的后端 │
|
// │ 内部编排，再记一条「请验单 提交」只会让列表出现用户没做过的动作行。 │
|
// │ 所以这条断言的**前提**（submit 有层 2 事件）不复存在，不是覆盖面丢失。 │
|
// │ │
|
// │ 谁接替：tasks/lims-sign-usage-checks.sh G 组「SUBMIT 埋点已删（恰好 0 处）」，│
|
// │ 同一个位置从「必须在」倒转成「必须不在」，且做过双向变异验证（加回来也红）。 │
|
// └────────────────────────────────────────────────────────────────────────────┘
|
check("取样 Layer 2 与消费事件共事务",
|
annotatedBusinessAction(qingyandanService, "action = \"FETCH\"", "public void fetch("),
|
"fetch 缺少 @AuditLog");
|
check("接样 Layer 2 与消费事件共事务",
|
annotatedBusinessAction(qingyandanService, "action = \"RECEIVE\"", "public void jieyangReceive("),
|
"jieyangReceive 缺少 @AuditLog");
|
check("请验单撤回使用稳定签名操作码",
|
signOpType.contains("QINGYANDAN_CANCEL(\"qingyandan_cancel\", \"请验单撤回\")"),
|
"缺少 QINGYANDAN_CANCEL 稳定 code");
|
checkCancelAffectedGuard(qingyandanService);
|
checkQingyandanEntityContract(qingyandanEntity);
|
check("SIGN_USED 写入 bizModule",
|
signService.contains(".bizModule(group.getBizModule())"),
|
"AuditEventDTO builder 未写 bizModule");
|
String publishSignUsed = methodBody(signService, "private void publishSignUsedEvents(");
|
check("SIGN_USED 将签名 note 写入 reason",
|
publishSignUsed.contains(".reason(sign.getNote())"),
|
"SIGN_USED AuditEventDTO 未把 lims_sign.note 映射到 reason");
|
checkSignClaimGuard(signService);
|
check("全部签名使用目标显式声明 bizModule", allTargetsDeclareBizModule(),
|
"存在未声明 bizModule 的 LimsSignUsageTarget.builder() 块");
|
|
System.out.println("=== SIGN_USED 接线断言：" + passed + " 通过 / " + failed + " 失败 ===");
|
System.exit(failed == 0 ? 0 : 1);
|
}
|
|
/**
|
* 取样 / 接样仍走本方法，语义未变（成功后仍应写 SIGN_USED），2026-07-31 <b>一字未动</b>。
|
* 请验单提交已 retarget 到 {@link #checkQingyandanSubmitClaim}。
|
*/
|
private static void checkConsumption(String label, String source, String opType) {
|
check(label + "校验签名", source.contains("SignOpType." + opType), opType + " 未接入");
|
int operation = source.indexOf("SignOpType." + opType);
|
int record = source.indexOf("recordSignUsage", operation);
|
check(label + "成功后记录 SIGN_USED", operation >= 0 && record > operation,
|
opType + " 后未调用 recordSignUsage");
|
}
|
|
/**
|
* 请验单提交：D8 之后<b>只做原子认领、不再写 SIGN_USED</b>。
|
*
|
* <p>取代原来的 {@code checkConsumption("请验单提交", ...)} 调用。除语义外还修掉了那边的
|
* <b>范围缺陷</b>：{@code source.indexOf("recordSignUsage", operation)} 是从某位置往后
|
* <b>在整个文件里</b>找，命中的其实是私有方法体内那行 {@code limsSignService.recordSignUsage(...)}，
|
* 与 submit 端点没有任何绑定关系——把 submit 里的调用整行删掉，那条断言照样绿。
|
* 本方法把搜索范围<b>夹在 submit 端点方法体内</b>，改坏 submit 才会红。
|
*
|
* <p>守的是<b>认领</b>不是事件：认领是「签名单次消费」的防重放护栏（ed4d908），
|
* 删掉等于同一个签名可以反复使用。D8 停的只是事件。
|
*
|
* <p>⚠️ 取样（{@code QUYANG_FETCH}）/ 接样（{@code JIEYANG_RECEIVE}）语义未变，
|
* 仍走 {@link #checkConsumption} 且一字未动。它们沿用的整文件 indexOf 有同样的范围缺陷，
|
* 但本期不在范围内，已记入 Task 8 报告待处理——不在这里顺手改，是为了让
|
* 「取样 / 接样没被改到」在 diff 上一眼可见。
|
*/
|
private static void checkQingyandanSubmitClaim(String source) {
|
String block = methodBody(source, "public R<String> qingyandanSubmit(");
|
// 判据写成**完整调用**而不是光一个 SignOpType.QINGYANDAN_SUBMIT：
|
// 认领那行也带着同一个枚举名，只查枚举名的话，把校验改成传 null 照样绿（变异 N3 实测）。
|
int verify = block.indexOf(
|
"requireQingyandanSign(qingyandan, formData, SignOpType.QINGYANDAN_SUBMIT)");
|
int business = block.indexOf("limsQingyandanService.submit(", verify);
|
int claim = block.indexOf("claimQingyandanSignUsageOnly(", business);
|
check("请验单提交按 QINGYANDAN_SUBMIT 校验签名", verify >= 0,
|
"submit 端点未按 QINGYANDAN_SUBMIT 校验签名");
|
// 顺序也钉死：认领必须在业务写库**之后**。提前认领 = 业务失败时签名已被消费，
|
// 正是 ed4d908 修掉的那个 bug。
|
check("请验单提交校验签名后执行、业务成功后才原子认领（不再写 SIGN_USED）",
|
verify >= 0 && business > verify && claim > business,
|
"submit 端点体内未在业务成功后调用 claimQingyandanSignUsageOnly"
|
+ " —— 防重放护栏丢失或顺序颠倒（ed4d908 回归）");
|
check("请验单提交不再走发事件路径",
|
!block.isEmpty()
|
&& !block.contains("recordQingyandanSignUsage(")
|
&& !block.contains("limsSignService.recordSignUsage("),
|
"submit 端点仍写 SIGN_USED，与层 0 据签名字段补写的签名事件重复（D8）");
|
}
|
|
/** 按方法签名夹出方法体（到同缩进的收尾大括号）；取不到时返回空串，让断言按红处理。 */
|
private static String methodBody(String source, String signature) {
|
int start = source.indexOf(signature);
|
if (start < 0) {
|
return "";
|
}
|
int end = source.indexOf("\n }", start);
|
return end > start ? source.substring(start, end) : "";
|
}
|
|
private static void checkCancelConsumption(String source) {
|
int cancelCase = source.indexOf("case \"cancel\":");
|
int operation = source.indexOf("SignOpType.QINGYANDAN_CANCEL", cancelCase);
|
int cancel = source.indexOf("limsQingyandanService.cancel", operation);
|
int record = source.indexOf("recordQingyandanSignUsage", cancel);
|
check("请验单撤回从请求读取签名",
|
source.contains("params.get(\"biz_sign\")") && source.contains("params.get(\"id\")"),
|
"撤回未读取 biz_sign 或兼容 id");
|
check("请验单撤回校验签名后执行且成功后记录 SIGN_USED",
|
cancelCase >= 0 && operation > cancelCase && cancel > operation && record > cancel,
|
"撤回的签名校验、业务更新、SIGN_USED 顺序错误");
|
}
|
|
private static void checkQingyandanFreshSign(String source) {
|
int start = source.indexOf("private LimsSignEntity requireQingyandanSign(");
|
int end = source.indexOf("private LimsSignEntity requireQingyandanActionSign(", start);
|
String block = start >= 0 && end > start ? source.substring(start, end) : "";
|
check("请验单提交和编辑必须携带本次签名",
|
block.contains("request.getBizSign()") && !block.contains("persisted.getBizSign()"),
|
"请求缺签名时仍会复用业务表中的历史 biz_sign");
|
}
|
|
private static void checkHuanjingFailureBoundary(String source,
|
String method,
|
String businessCall,
|
String opType) {
|
int methodAt = source.indexOf(method);
|
int nextMethod = source.indexOf("\n public ", methodAt + method.length());
|
String block = methodAt >= 0
|
? source.substring(methodAt, nextMethod > methodAt ? nextMethod : source.length())
|
: "";
|
int validation = block.indexOf("limsSignService.requireValidSign(");
|
int catchAt = block.indexOf("catch (DataException e)", validation);
|
int catchClose = block.indexOf("\n }", catchAt);
|
int business = block.indexOf(businessCall, catchClose);
|
int record = block.indexOf("recordHuanjingSignUsage", business);
|
check("环境监测 " + opType + " 只捕获签名校验异常",
|
validation >= 0 && catchAt > validation && catchClose > catchAt
|
&& business > catchClose && record > business,
|
"业务更新或 SIGN_USED 仍在 DataException 捕获范围内");
|
}
|
|
private static void checkCancelAffectedGuard(String source) {
|
int start = source.indexOf("public boolean cancel(");
|
int end = source.indexOf("\n @Override", start);
|
String block = start >= 0 && end > start ? source.substring(start, end) : "";
|
int conditionalUpdate = block.indexOf("update.eq(\"biz_status\", BizStatus.CONFIRMED.getCode())");
|
int zeroReturn = block.indexOf("return false;");
|
int softDelete = block.indexOf("softDeleteJianyanXiangRecords");
|
check("请验单撤回按 confirmed 状态原子更新",
|
block.contains("activeRowUpdate(qingyandan.getId())") && conditionalUpdate >= 0,
|
"cancel 缺少状态或未删除条件");
|
check("affected=0 不执行撤回副作用",
|
zeroReturn > conditionalUpdate && softDelete > zeroReturn,
|
"cancel 在确认更新命中前执行了软删除");
|
check("affected=0 不生成业务事件",
|
source.substring(Math.max(0, source.lastIndexOf("@AuditLog(", start)), start)
|
.contains("#result ? #qingyandan.jianyanLiushuihao : null"),
|
"cancel 的 @AuditLog 未按返回值跳过 0 行事件");
|
}
|
|
private static void checkQingyandanEntityContract(String entity) {
|
String[] fields = {"qingyan_fenlei", "zhouqi", "zhouqi_danwei"};
|
for (String field : fields) {
|
check("实体包含请验字段 " + field,
|
entity.contains("@TableField(\"" + field + "\")"),
|
field + " 的实体契约不完整");
|
}
|
}
|
|
private static void checkSignClaimGuard(String source) {
|
int requireStart = source.indexOf("public LimsSignEntity requireValidSign(");
|
int recordStart = source.indexOf("public void recordSignUsage(", requireStart);
|
String requireBlock = requireStart >= 0 && recordStart > requireStart
|
? source.substring(requireStart, recordStart) : "";
|
int claim = source.indexOf("claimSignUsage(sign, opType, usageJson)", recordStart);
|
int event = source.indexOf("auditClientProvider.ifAvailable", recordStart);
|
check("签名校验不提前写库认领",
|
!requireBlock.contains("updateById(") && !requireBlock.contains("this.update("),
|
"requireValidSign 仍会在业务成功前写签名");
|
check("已消费签名不可跨业务周期复用",
|
requireBlock.contains("sign.getExtraJson()")
|
&& requireBlock.contains("电子签名已被使用，请重新签名")
|
&& source.contains("w.isNull(\"extra_json\").or().eq(\"extra_json\", \"\")")
|
&& !source.contains(".or().eq(\"extra_json\", usageJson)"),
|
"extra_json 已有值时仍可能再次消费同一签名");
|
check("签名成功后先原子认领再记录事件",
|
claim > recordStart && event > claim
|
&& source.contains("w.isNull(\"op_type\")")
|
&& source.contains("w.isNull(\"data_id\")")
|
&& source.contains("w.isNull(\"extra_json\")"),
|
"SIGN_USED 缺少认领冲突条件或事件顺序错误");
|
check("签名认领失败标记事务回滚",
|
source.contains("currentTransactionStatus().setRollbackOnly()")
|
&& source.contains("throw signUsageFailure("),
|
"controller 捕获 DataException 时事务可能继续提交");
|
}
|
|
private static boolean annotatedBusinessAction(String source, String action, String method) {
|
int methodAt = source.indexOf(method);
|
int actionAt = source.lastIndexOf(action, methodAt);
|
int annotationAt = source.lastIndexOf("@AuditLog(", methodAt);
|
return methodAt >= 0 && annotationAt >= 0 && actionAt > annotationAt
|
&& methodAt - annotationAt < 600;
|
}
|
|
private static boolean allTargetsDeclareBizModule() throws IOException {
|
Path root = Paths.get("jnpf-lims");
|
try (Stream<Path> files = Files.walk(root)) {
|
return files.filter(path -> path.toString().contains("/src/main/java/")
|
&& path.toString().endsWith(".java"))
|
.allMatch(LimsSignUsageWiringProbe::targetBlocksDeclareBizModule);
|
}
|
}
|
|
private static boolean targetBlocksDeclareBizModule(Path path) {
|
try {
|
String source = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
|
int from = 0;
|
while (true) {
|
int builder = source.indexOf("LimsSignUsageTarget.builder()", from);
|
if (builder < 0) {
|
return true;
|
}
|
int build = source.indexOf(".build()", builder);
|
if (build < 0 || !source.substring(builder, build).contains(".bizModule(")) {
|
return false;
|
}
|
from = build + 8;
|
}
|
} catch (IOException e) {
|
throw new IllegalStateException("读取源码失败: " + path, e);
|
}
|
}
|
|
private static String read(String path) throws IOException {
|
return new String(Files.readAllBytes(Paths.get(path)), StandardCharsets.UTF_8);
|
}
|
|
private static void check(String name, boolean ok, String detail) {
|
if (ok) {
|
passed++;
|
System.out.println(" [PASS] " + name);
|
} else {
|
failed++;
|
System.out.println(" [FAIL] " + name + " -- " + detail);
|
}
|
}
|
|
private LimsSignUsageWiringProbe() {
|
}
|
}
|
