authorizedPaths(BoaUser user) {
+ return FormModuleKeys.paths(moduleTreeSource.authorizedModules(user));
+ }
+
+ /** 是否被授权某个模块行（path 精确匹配；超管直接放行） */
+ private boolean hasModule(BoaUser user, String modulePath) {
+ return isSuperAdmin(user) || authorizedPaths(user).contains(modulePath);
}
private boolean isSuperAdmin(BoaUser user) {
return user.getType() != null && user.getType() == SUPER_ADMIN_TYPE;
}
- private boolean hasSchoolAdminRole(BoaUser user) {
- return user.getRoleIds() != null && user.getRoleIds().stream().anyMatch(ADMIN_ROLE_IDS::contains);
- }
-
private Long currentSchId(BoaUser user) {
if (user.getCurrentRole() == null || user.getCurrentRole().getSchId() == null) {
return null;
diff --git a/src/main/java/com/yunhai/formcenter/service/FormDefService.java b/src/main/java/com/yunhai/formcenter/service/FormDefService.java
index 4f1e828..7d8744a 100644
--- a/src/main/java/com/yunhai/formcenter/service/FormDefService.java
+++ b/src/main/java/com/yunhai/formcenter/service/FormDefService.java
@@ -56,8 +56,9 @@ public class FormDefService {
private static final Pattern CODE_PATTERN = Pattern.compile("^[A-Za-z0-9_\\-]{1,64}$");
/**
- * 开报名号时的 code 长度上限：{@code -yyyyMMdd-} 占 9 位，序号留到 5 位（单日上万）仍不越界
- * {@code answer_no varchar(64)}（契约 §10）→ 64-9-6=49，留 1 位余量。
+ * 开报名号时的 code 长度上限：{@code -yyyyMMdd-} 占 10 位（两个连字符 + 8 位日期），
+ * 当日序号预留 5 位（单日超万）→ {@code 64-10-5=49}，保证 {@code answer_no varchar(64)}
+ * （契约 §10）装得下。开关处拦住，好过提交当天报库错。
*/
static final int MAX_CODE_LEN_FOR_ANSWER_NO = 49;
@@ -69,6 +70,7 @@ public class FormDefService {
private final FormRepository formRepository;
private final FormVersionRepository versionRepository;
private final FormDictService dictService;
+ private final AnswerIndexService indexService;
// ==================== 读 ====================
@@ -180,44 +182,53 @@ public class FormDefService {
}
/**
- * 数据面解析答卷钉住的版本行（T3 编辑/软删/改状态用）：按同一条校域遮蔽规则取头表，
- * 再取该版本行；不校验生命周期——方案 §5.4"停用只断填报入口、数据读改接口不变"，
+ * 数据面解析答卷钉住的版本行（编辑/软删/改状态 + T4 全部读路径）：
+ * 按 {@code answer.form_uuid} → {@code form}(uk_form_uuid) → 该头表下 {@code version} 的行，
+ * 精确取数、不经遮蔽规则、不校验生命周期——方案 §5.4"停用只断填报入口、数据读改接口不变"，
* 升版期间的旧版答卷同样必须可管理。
*
- * 一处歧义窗口按"退回平台级行"处理：答卷的钉版坐标是 {@code (会话校, app_code, code, version)}
- * （契约 §1 校域不变式：{@code answer.sch_id} 恒=会话校），若它当初投的是平台级表单、
- * 而本校后来建了同 {@code (app_code, code)} 的表单，遮蔽规则会把解析指向本校表单且版本号可能对不上——
- * 此时退回平台级同 code 表单的版本行，历史答卷仍按原 schema 校验。
- * 根因与替代方案见 T3 报告问题单。
+ * 为什么按 form_uuid 而不是 (校, app_code, code, version)（P25 裁决，替代 T3 的回退启发式）：
+ * 那组坐标不含"表单归属校"，平台级表单被本校后建的同 {@code (app_code,code)} 表单遮蔽后会出现歧义窗口，
+ * 版本号恰好对上时历史答卷被静默按错 schema 校验/重建索引——比查不到更难发现。
+ * uuid 跨版本不变（契约 §1），按它取数没有这个窗口；代价是历史行必须有该列，
+ * 本轮开发库答卷零行、无回填（系统未上线=零迁移成本窗口，H3 同款论证）。
+ *
+ * 本方法不过滤 {@code form.is_deleted}：表单软删是唯一切除形态且无物理删除，
+ * 存量答卷的定义溯源不能因为表单被软删而断掉（P32/方案 §5.4）。
*/
- public Published pinnedForData(Long schId, String appCode, String code, Integer version) {
- String cleanApp = normalizeAppCode(appCode);
- // 数据面取域含软删表单：答卷的定义溯源不能因为表单被软删而断掉（无物理删除，方案 §5.4）
- Form form = pickByShadowing(
- formRepository.findDataDomainCandidates(code, cleanApp, resolveDomain(schId)), schId);
+ public Published pinnedForData(String formUuid, Integer version) {
+ if (formUuid == null || formUuid.trim().isEmpty()) {
+ throw new BizException(ErrorCode.PARAM_ERROR, "答卷缺少 form_uuid，无法溯源钉住版本");
+ }
+ Form form = formRepository.findByUuid(formUuid.trim()).orElse(null);
if (form == null) {
- throw new BizException(ErrorCode.PARAM_ERROR, "表单不存在：" + cleanApp + "/" + code);
+ throw new BizException(ErrorCode.PARAM_ERROR, "答卷归属的表单已不存在：" + formUuid);
}
FormVersion row = versionRepository.findByFormIdAndVersion(form.getId(), version).orElse(null);
- if (row == null && form.getSchId() != null && form.getSchId() != Form.PLATFORM_SCH_ID) {
- Form platform = formRepository.findBySchIdAndAppCodeAndCode(Form.PLATFORM_SCH_ID, cleanApp, code)
- .orElse(null);
- if (platform != null) {
- FormVersion platformRow = versionRepository.findByFormIdAndVersion(platform.getId(), version)
- .orElse(null);
- if (platformRow != null) {
- form = platform;
- row = platformRow;
- }
- }
- }
if (row == null) {
throw new BizException(ErrorCode.PARAM_ERROR,
- "答卷钉住的版本行不存在：" + cleanApp + "/" + code + " v" + version);
+ "答卷钉住的版本行不存在：" + form.getAppCode() + "/" + form.getCode() + " v" + version);
}
return new Published(form, row);
}
+ /**
+ * 数据面读路径的表单定位（T4 列表/统计/导出/筛选候选）：按 {@code form_uuid} 取头表，
+ * 域=会话校 ∪ 平台级（契约 §1）——答卷按 {@code sch_id} 租户隔离，表单本身可能是本校的或平台级的。
+ * 他校表单与不存在的表单同一口径拒绝（uuid 不可枚举，差别信息就是探测面，同 {@link #requireForm}）。
+ */
+ public Form readDomainForm(Long sessionSchId, String formUuid) {
+ if (formUuid == null || formUuid.trim().isEmpty()) {
+ throw new BizException(ErrorCode.PARAM_ERROR, "formUuid 不能为空");
+ }
+ Form form = formRepository.findByUuid(formUuid.trim()).orElse(null);
+ if (form == null || form.getSchId() == null
+ || !(form.getSchId().equals(sessionSchId) || form.getSchId() == Form.PLATFORM_SCH_ID)) {
+ throw new BizException(ErrorCode.PARAM_ERROR, "表单不存在：" + formUuid);
+ }
+ return form;
+ }
+
// ==================== 写：草稿/发布/生命周期 ====================
/** 建草稿：uuid 当场生成、跨版本不变（契约 §1） */
@@ -314,6 +325,9 @@ public class FormDefService {
form.setCurrentVersion(draft.getVersion());
form.setStatus(FormEnums.FormStatus.PUBLISHED.getCode());
formRepository.save(form);
+ // V9：新版本新声明的 searchable 字段，要在历史答卷上补出索引行，否则"旧数据按新字段筛"落不了地。
+ // 只增不删（与 V8 的"新版本删字段不清历史行"同向），幂等可重入。见 AnswerIndexService 注释。
+ indexService.backfillAfterPublish(form.getUuid(), draft.getSchemaJson());
return toView(form, null);
}
@@ -380,8 +394,8 @@ public class FormDefService {
throw new BizException(ErrorCode.PARAM_ERROR, "answerNoEnabled 只能是 0 或 1");
}
if (req.getAnswerNoEnabled() == 1) {
- // 报名号形态 {code}-{yyyyMMdd}-{4 位序号} 必须装得进 answer_no varchar(64)（契约 §10）：
- // 9 个分隔/日期字符 + 4 位序号占掉 13，code 上限因此是 51。开关处拦住，好过提交当天报库错。
+ // 报名号形态 {code}-{yyyyMMdd}-{当日序号} 必须装得进 answer_no varchar(64)（契约 §10）：
+ // -yyyyMMdd- 占 10 位、序号预留 5 位，code 上限因此是 49（MAX_CODE_LEN_FOR_ANSWER_NO）。
if (form.getCode().length() > MAX_CODE_LEN_FOR_ANSWER_NO) {
throw new BizException(ErrorCode.PARAM_ERROR,
"开启报名号要求 code ≤" + MAX_CODE_LEN_FOR_ANSWER_NO + " 位（当前 "
diff --git a/src/main/java/com/yunhai/formcenter/service/ModuleTreeSource.java b/src/main/java/com/yunhai/formcenter/service/ModuleTreeSource.java
new file mode 100644
index 0000000..cda853b
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/ModuleTreeSource.java
@@ -0,0 +1,29 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.platform.utils.model.BoaModule;
+import com.yunhai.platform.utils.model.BoaUser;
+
+import java.util.List;
+
+/**
+ * 会话用户在本应用下的已授权模块树来源（方案 §6.1 第②层，权限模型的唯一权威载体）。
+ *
+ * T4 起两类判断都从这棵树出，共用同一个接口（执行手册 §5 P21/P30 裁决落地口径）：
+ *
+ * - 管理权：定义管理/数据管理/统计/字典管理=被授权对应模块行（path 命中，手册 §2.2 表）；
+ * - 数据范围：{@code fc:scope:all} 授权锚点=这棵树里 path 空、customId 为该值的纯权限位
+ * （契约 §8 扩展协议）。
+ *
+ *
+ * 做成策略接口的原因与 {@link SubjectDirectory} 同一条：事实源在 UserBase。
+ * 生产实现走平台标准签名调用（{@code /oapi/user/modules}，签名由 starter 装配的出站链负责）；
+ * 本地 IT 不启动 UserBase/CAS，注入桩即可断言权限矩阵本身，真实链路 T9 联调验。
+ *
+ * 失败口径=fail-closed：不可达或异常按"无任何授权模块"处理（管理权被拒、范围回落到仅本人提交），
+ * 与契约 §8"全不命中=仅本人提交（宁紧勿松）"同向。
+ */
+public interface ModuleTreeSource {
+
+ /** 该用户在表单中心应用下的已授权模块树（含 path 空的权限锚点）；无授权或不可达=空列表 */
+ List authorizedModules(BoaUser user);
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/OapiFormService.java b/src/main/java/com/yunhai/formcenter/service/OapiFormService.java
new file mode 100644
index 0000000..97e1d39
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/OapiFormService.java
@@ -0,0 +1,117 @@
+package com.yunhai.formcenter.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.yunhai.formcenter.common.FormSchemaValidator;
+import com.yunhai.formcenter.common.FormValueSchemaBuilder;
+import com.yunhai.formcenter.entity.Answer;
+import com.yunhai.formcenter.entity.Form;
+import com.yunhai.formcenter.enums.FormEnums;
+import com.yunhai.formcenter.model.OapiModels;
+import com.yunhai.formcenter.repository.AnswerRepository;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.exception.ErrorCode;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+/**
+ * 一期对外读接口服务（契约 §9 两端点）。
+ *
+ * 身份与租户：{@code schId} 是调用方声明的租户域（应用签名已核实调用方身份，
+ * 与 flow-center {@code /oapi/flow/**} 同一口径："应用签名不替代谁能看"——消费方对自己侧的
+ * 用户可见性负责，本层只保证不跨校取数：答卷按 {@code (uuid, sch_id)} 定位，跨校一律查不到，
+ * 表单按 resolve 的"会话校 ∪ 平台级、本校遮蔽"规则解析。
+ *
+ * 与 CAS 读路径的分工：契约 §8 的行级数据范围矩阵挂在会话身份上，oapi 面没有会话用户
+ * （签名方是应用），因此不走 {@link AnswerScopeQueryBuilder}——它给的是"这张表的结构"与"这一条答卷"，
+ * 批量读（列表/统计/导出）在对外面上根本不存在，越权面按端点形状就被关死（一期对外只读单条与 schema，
+ * 不提供全量拉取）。这一条写清楚，避免后来人"顺手"加一个 /oapi/form/list。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class OapiFormService {
+
+ /** 契约 §9 只给 schId+code 两个参数，归属应用缺省=form-center（手册 §1）；快应用表单显式传 appCode */
+ private static final String DEFAULT_APP_CODE = Form.CENTER_APP_CODE;
+
+ private final FormDefService defService;
+ private final FormDictService dictService;
+ private final AnswerRepository answerRepository;
+
+ /**
+ * 机读 schema（契约 §4 形状）：字典已内联展开，每个字段附 valueSchema。
+ *
+ * @param schId 租户域（调用方声明）
+ * @param appCode 归属应用，可空=form-center
+ * @param code 表单 code
+ */
+ public OapiModels.SchemaView schema(Long schId, String appCode, String code) {
+ requireSchId(schId);
+ FormDefService.Published published = defService.resolvePublished(schId,
+ appCode == null || appCode.trim().isEmpty() ? DEFAULT_APP_CODE : appCode.trim(), code);
+ Form form = published.form();
+ JsonNode root = FormValueSchemaBuilder.withValueSchemas(expandedRoot(form, published.versionRow().getSchemaJson()));
+
+ OapiModels.SchemaView view = new OapiModels.SchemaView();
+ view.setFormUuid(form.getUuid());
+ view.setVersion(published.versionRow().getVersion());
+ view.setCode(form.getCode());
+ view.setAppCode(form.getAppCode());
+ view.setAudience(FormEnums.Audience.nameOf(form.getAudience()));
+ view.setGroups(root.path("groups"));
+ return view;
+ }
+
+ /**
+ * 单条答卷（契约 §9）：钉住版本的内联 schema + 值文档。
+ * 软删答卷对外不可见（与四条 CAS 读路径同一口径，V30）。
+ */
+ public OapiModels.AnswerView answer(Long schId, String answerId) {
+ requireSchId(schId);
+ if (answerId == null || answerId.trim().isEmpty()) {
+ throw new BizException(ErrorCode.PARAM_ERROR, "answerId 不能为空");
+ }
+ Answer answer = answerRepository.findByUuidAndSchId(answerId.trim(), schId).orElse(null);
+ if (answer == null || Integer.valueOf(1).equals(answer.getIsDeleted())) {
+ // 与 CAS 面同口径：不存在与跨校同一回答，不给探测面（契约 §1 uuid 不可枚举）
+ throw new BizException(ErrorCode.PARAM_ERROR, "答卷不存在：" + answerId);
+ }
+ FormDefService.Published pinned = defService.pinnedForData(answer.getFormUuid(), answer.getVersion());
+ Form form = pinned.form();
+ JsonNode root = expandedRoot(form, pinned.versionRow().getSchemaJson());
+
+ OapiModels.AnswerView view = new OapiModels.AnswerView();
+ view.setAnswerId(answer.getUuid());
+ view.setFormUuid(answer.getFormUuid());
+ view.setAppCode(answer.getAppCode());
+ view.setCode(answer.getCode());
+ view.setVersion(answer.getVersion());
+ view.setStatus(answer.getStatus());
+ view.setSubmitterId(answer.getSubmitterId());
+ view.setSubjectId(answer.getSubjectId());
+ view.setAnswerNo(answer.getAnswerNo());
+ view.setSubmitTime(AnswerReadService.format(answer.getCreateTime()));
+ view.setValues(FormSchemaValidator.parse(answer.getValuesJson(), "答卷值文档损坏"));
+ OapiModels.SchemaRef ref = new OapiModels.SchemaRef();
+ ref.setFormUuid(form.getUuid());
+ ref.setAppCode(form.getAppCode());
+ ref.setCode(form.getCode());
+ ref.setVersion(answer.getVersion());
+ view.setSchemaRef(ref);
+ view.setGroups(root.path("groups"));
+ return view;
+ }
+
+ /** 字典内联展开 → JSON 树（对外自包含，契约 §2.1） */
+ private JsonNode expandedRoot(Form form, String schemaJson) {
+ return FormSchemaValidator.parse(dictService.expandSchema(form.getSchId(), schemaJson),
+ "表单结构损坏（请联系管理员）");
+ }
+
+ private void requireSchId(Long schId) {
+ if (schId == null || schId < 0) {
+ throw new BizException(ErrorCode.PARAM_ERROR, "schId 必填（调用方声明的租户域，≥0）");
+ }
+ }
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/PlatformModuleTreeSource.java b/src/main/java/com/yunhai/formcenter/service/PlatformModuleTreeSource.java
new file mode 100644
index 0000000..dddf885
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/PlatformModuleTreeSource.java
@@ -0,0 +1,40 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.platform.openapi.base.YschBaseOpenApi;
+import com.yunhai.platform.utils.model.BoaModule;
+import com.yunhai.platform.utils.model.BoaUser;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * {@link ModuleTreeSource} 的生产实现：平台标准签名调用 UserBase {@code /oapi/user/modules}
+ * （经 SDK {@code YschBaseOpenApi.getUserModule(userId, schId)}，与前端壳 GetUserMod 同一条链路、
+ * 同一个数据源——管理权与导航菜单因此不会有两套口径，方案 §6.1 运行时链路）。
+ *
+ * {@code schId} 传会话学校=把授权限定在该学校上下文（UserBase 侧只取该校子树内的真实归属组参与判定）；
+ * 无学校归属的身份（区域组/根直属）传 null，按 UserBase 语义取全部归属组。
+ */
+@Slf4j
+@Service
+public class PlatformModuleTreeSource implements ModuleTreeSource {
+
+ @Override
+ public List authorizedModules(BoaUser user) {
+ if (user == null || user.getId() == null) {
+ return Collections.emptyList();
+ }
+ Integer schId = user.getCurrentRole() == null ? null : user.getCurrentRole().getSchId();
+ try {
+ List modules = YschBaseOpenApi.getUserModule(user.getId(), schId);
+ return modules == null ? Collections.emptyList() : modules;
+ } catch (Exception e) {
+ // fail-closed：取不到树就当没有授权——管理权拒、数据范围回落到仅本人提交（接口注释）
+ log.warn("[模块树] UserBase /oapi/user/modules 不可达，按无授权处理 userId={} schId={}：{}",
+ user.getId(), schId, e.getMessage());
+ return Collections.emptyList();
+ }
+ }
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/PlatformSubjectDirectory.java b/src/main/java/com/yunhai/formcenter/service/PlatformSubjectDirectory.java
new file mode 100644
index 0000000..a45c260
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/PlatformSubjectDirectory.java
@@ -0,0 +1,74 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.platform.openapi.base.OpenApiUserClient;
+import com.yunhai.platform.utils.model.BoaGroup;
+import com.yunhai.platform.utils.model.BoaUser;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * {@link SubjectDirectory} 的生产实现：平台标准签名调用 UserBase {@code GET /oapi/user/byId?id=}
+ * （经 starter 装配的 {@link OpenApiUserClient}，签名四件套由出站拦截器负责，本工程不私写签名、
+ * 不直连 UserBase 库）。每次提交只验一个 id，byId 单查够用，不需要批量端点（P33 裁决）。
+ *
+ * 失败口径见接口注释：不可达与查不到都返回 false（fail-closed），差异只落在日志上便于排查
+ * ——flow-center {@code AssigneeResolver#requireUserName} 同款分档。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PlatformSubjectDirectory implements SubjectDirectory {
+
+ private final OpenApiUserClient userClient;
+
+ @Override
+ public boolean existsInSchool(Integer subjectId, Long schId) {
+ if (subjectId == null || schId == null) {
+ return false;
+ }
+ BoaUser subject;
+ try {
+ subject = userClient.getUserById(String.valueOf(subjectId));
+ } catch (Exception e) {
+ log.warn("[代填校验] UserBase 不可达，按查不到处理 subjectId={}：{}", subjectId, e.getMessage());
+ return false;
+ }
+ if (subject == null) {
+ log.warn("[代填校验] UserBase 查无此人 subjectId={}", subjectId);
+ return false;
+ }
+ if (!belongsToSchool(subject, schId)) {
+ log.warn("[代填校验] subjectId={} 的学校归属不含 schId={}", subjectId, schId);
+ return false;
+ }
+ return true;
+ }
+
+ /**
+ * 学校归属判定：{@code schools}（用户全部可选身份的学校集合，UserBase 本期起填充）为主，
+ * {@code school}（当前激活学校）与 {@code currentRole.schId} 为兜底——三者任一含目标校即算同校。
+ * 纯函数，脱库可单测。
+ */
+ static boolean belongsToSchool(BoaUser subject, Long schId) {
+ if (subject == null || schId == null) {
+ return false;
+ }
+ List schools = subject.getSchools();
+ if (schools != null) {
+ for (BoaGroup group : schools) {
+ if (group != null && group.getId() != null && group.getId().longValue() == schId) {
+ return true;
+ }
+ }
+ }
+ BoaGroup school = subject.getSchool();
+ if (school != null && school.getId() != null && school.getId().longValue() == schId) {
+ return true;
+ }
+ return subject.getCurrentRole() != null && subject.getCurrentRole().getSchId() != null
+ && subject.getCurrentRole().getSchId().longValue() == schId;
+ }
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/SelfSubmittedScopeImplementor.java b/src/main/java/com/yunhai/formcenter/service/SelfSubmittedScopeImplementor.java
new file mode 100644
index 0000000..0936f24
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/SelfSubmittedScopeImplementor.java
@@ -0,0 +1,35 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.Answer;
+import com.yunhai.formcenter.enums.FormEnums.DataScope;
+import org.springframework.stereotype.Component;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+/**
+ * 范围实现器：仅本人提交（{@code submitter_id}=会话用户）。
+ *
+ * 这是契约 §8 的兜底值："全不命中=仅本人提交（宁紧勿松）"，也是教师×面向学生表单在 1.5
+ * 之前的实际生效值（任教班级实现器缺席，方案 §6.4 表格里写明了要防"教师怎么只看到自己"被当 bug 报）。
+ * 走 {@code idx_answer_submitter(sch_id, submitter_id)}。
+ */
+@Component
+public class SelfSubmittedScopeImplementor implements AnswerScopeImplementor {
+
+ @Override
+ public DataScope scope() {
+ return DataScope.SELF_SUBMITTED;
+ }
+
+ @Override
+ public boolean selectable() {
+ return true;
+ }
+
+ @Override
+ public Predicate rowPredicate(CriteriaBuilder cb, Root root, Integer userId) {
+ return cb.equal(root.get("submitterId"), userId);
+ }
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/SubjectDirectory.java b/src/main/java/com/yunhai/formcenter/service/SubjectDirectory.java
new file mode 100644
index 0000000..4c79c16
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/SubjectDirectory.java
@@ -0,0 +1,29 @@
+package com.yunhai.formcenter.service;
+
+/**
+ * 被代填人（{@code answer.subject_id}）的存在性与学校归属解析（执行手册 §5 P33 裁决）。
+ *
+ * 为什么要这层抽象：这个判断的事实源在 UserBase，不在本库。把它做成策略接口而不是
+ * 在业务服务里直连 UserBase 库或自己拼签名，是为了——
+ *
+ * - 生产实现走平台标准签名调用（{@code GET /oapi/user/byId?id=}，签名四件套由 starter 装配的
+ * 出站拦截器负责，本工程不私写签名逻辑）；
+ * - 本地/IT 环境不启动 UserBase 与 CAS，测试注入桩即可断言"查不到 / 跨校 → 拒"这条规则本身，
+ * 真实链路按裁决在 T9 联调验；
+ * - V18 的"关于我的"视图依赖 subject id 指向真实存在的人，这道校验是它的前提。
+ *
+ *
+ * 口径：解析不出或不可达一律按"查不到"处理（fail-closed）。代填是低频动作
+ * （管理员录一条数据），宁可让管理员重试一次，不可把不存在/他校的人挂进本校数据。
+ */
+public interface SubjectDirectory {
+
+ /**
+ * 该 id 是否是本校真实存在的用户。
+ *
+ * @param subjectId 被代填人 id
+ * @param schId 会话校（= {@code answer.sch_id}，校域不变式）
+ * @return 存在且其学校归属包含 {@code schId} 才 true；查不到、跨校、UserBase 不可达都返回 false
+ */
+ boolean existsInSchool(Integer subjectId, Long schId);
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/TeachingClassScopeImplementor.java b/src/main/java/com/yunhai/formcenter/service/TeachingClassScopeImplementor.java
new file mode 100644
index 0000000..5bd2a95
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/TeachingClassScopeImplementor.java
@@ -0,0 +1,42 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.Answer;
+import com.yunhai.formcenter.enums.FormEnums.DataScope;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.exception.ErrorCode;
+import org.springframework.stereotype.Component;
+
+import javax.persistence.criteria.CriteriaBuilder;
+import javax.persistence.criteria.Predicate;
+import javax.persistence.criteria.Root;
+
+/**
+ * 范围实现器：任教班级——1.5 占位（契约 §8 / 方案 §6.4）。
+ *
+ * 存在意义就是把 V28 的两半钉在代码里：枚举值在（一期契约即含四值，定了就不变），
+ * 但 {@link #selectable()} 为 false，{@code DataScopeService} 因此永远不会把它放进解析结果，
+ * 教师×面向学生表单在一期按矩阵注明的"实际生效=仅本人提交"落地。
+ *
+ * 1.5 开放时的改动面就在本类：接 UserClass（原 BschClass）的任教关系/班级 SDK，把
+ * {@code rowPredicate} 换成"submitter 的任教班级 ∩ 答卷班级列"或按 subject 的班级归属判定，
+ * {@code selectable()} 翻成 true——读路径与管理动作不用改（它们只认 {@link AnswerScopeQueryBuilder}）。
+ */
+@Component
+public class TeachingClassScopeImplementor implements AnswerScopeImplementor {
+
+ @Override
+ public DataScope scope() {
+ return DataScope.TEACHING_CLASS;
+ }
+
+ @Override
+ public boolean selectable() {
+ return false;
+ }
+
+ @Override
+ public Predicate rowPredicate(CriteriaBuilder cb, Root root, Integer userId) {
+ // 防御性：一期解析不会产生该范围（selectable=false），走到这里说明有人绕过了矩阵解析
+ throw new BizException(ErrorCode.CUSTOM, "数据范围 任教班级 一期未开放（1.5 依赖 UserClass 任教关系）");
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/common/FormFilterOperatorsTest.java b/src/test/java/com/yunhai/formcenter/common/FormFilterOperatorsTest.java
new file mode 100644
index 0000000..3f3c71e
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/common/FormFilterOperatorsTest.java
@@ -0,0 +1,157 @@
+package com.yunhai.formcenter.common;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.yunhai.formcenter.model.ReadModels;
+import com.yunhai.platform.apistd.BizException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.math.BigDecimal;
+import java.time.LocalDate;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * 检索算子收敛单测（契约 §2"算子按 type 收敛，不给自由表达式"+ V4 的日期按日期比 + P28 附件无算子）。
+ *
+ * 这一层是"筛选注入面"的关口：请求只能给 {@code {key,value}} 或 {@code {key,from,to}}，
+ * 落到哪一列（v_str/v_num/v_date）、用哪种算子（等值/前缀/区间）由字段类型定，
+ * 且解析不出正确类型的值一律拒（不允许"字符串当数字比"或"日期走字典序"那种静默降级）。
+ */
+@DisplayName("FormFilterOperators - 算子按类型收敛（V3/V4/P28）")
+class FormFilterOperatorsTest {
+
+ private static final String SCHEMA = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"name\",\"type\":\"text\",\"label\":\"姓名\",\"searchable\":true},"
+ + "{\"key\":\"grade\",\"type\":\"select\",\"label\":\"年级\",\"searchable\":true,"
+ + "\"options\":[{\"label\":\"高二\",\"value\":\"g2\"}]},"
+ + "{\"key\":\"subjects\",\"type\":\"checkbox\",\"label\":\"学科\",\"searchable\":true,"
+ + "\"options\":[{\"label\":\"数学\",\"value\":\"math\"}]},"
+ + "{\"key\":\"score\",\"type\":\"number\",\"label\":\"分数\",\"searchable\":true},"
+ + "{\"key\":\"birthday\",\"type\":\"date\",\"label\":\"出生日期\",\"searchable\":true},"
+ + "{\"key\":\"cert\",\"type\":\"upload\",\"label\":\"证书\",\"searchable\":true}"
+ + "]}]}";
+
+ @Test
+ @DisplayName("选项类等值、文本类前缀、数值与日期区间——候选算子逐类给对（下发前端用于出控件）")
+ void operatorsByType() {
+ assertThat(FormFilterOperators.operatorOf("select")).isEqualTo("EQ");
+ assertThat(FormFilterOperators.operatorOf("radio")).isEqualTo("EQ");
+ assertThat(FormFilterOperators.operatorOf("checkbox")).isEqualTo("EQ");
+ assertThat(FormFilterOperators.operatorOf("multiselect")).isEqualTo("EQ");
+ assertThat(FormFilterOperators.operatorOf("text")).isEqualTo("PREFIX");
+ assertThat(FormFilterOperators.operatorOf("textarea")).isEqualTo("PREFIX");
+ assertThat(FormFilterOperators.operatorOf("phone")).isEqualTo("PREFIX");
+ assertThat(FormFilterOperators.operatorOf("number")).isEqualTo("RANGE");
+ assertThat(FormFilterOperators.operatorOf("date")).isEqualTo("RANGE");
+ assertThat(FormFilterOperators.operatorOf("upload")).isNull();
+ assertThat(FormFilterOperators.operatorOf("image")).isNull();
+
+ assertThat(FormFilterOperators.columnOf("select")).isEqualTo(FormFilterOperators.Column.STR);
+ assertThat(FormFilterOperators.columnOf("text")).isEqualTo(FormFilterOperators.Column.STR);
+ assertThat(FormFilterOperators.columnOf("number")).isEqualTo(FormFilterOperators.Column.NUM);
+ assertThat(FormFilterOperators.columnOf("date")).isEqualTo(FormFilterOperators.Column.DATE);
+ assertThat(FormFilterOperators.columnOf("upload")).isNull();
+ }
+
+ @Test
+ @DisplayName("V4：date 落 v_date 列且严格 yyyy-MM-dd——2023-1-9 这种形态直接拒，不进字典序比较")
+ void dateIsTypedNotLexical() {
+ FormFilterOperators.Spec spec = FormFilterOperators.resolve(field("birthday"),
+ range("birthday", "2023-01-09", "2023-01-10"));
+ assertThat(spec.getColumn()).isEqualTo(FormFilterOperators.Column.DATE);
+ assertThat(spec.getDateFrom()).isEqualTo(LocalDate.of(2023, 1, 9));
+ assertThat(spec.getDateTo()).isEqualTo(LocalDate.of(2023, 1, 10));
+ assertThat(spec.getKind()).isEqualTo(FormFilterOperators.Kind.RANGE);
+
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("birthday"),
+ value("birthday", "2023-1-9")))
+ .isInstanceOf(BizException.class).hasMessageContaining("yyyy-MM-dd");
+ }
+
+ @Test
+ @DisplayName("number 走 v_num 数值区间；非数字串被拒（不静默转 0 或跳过）")
+ void numberIsNumericRange() {
+ FormFilterOperators.Spec spec = FormFilterOperators.resolve(field("score"),
+ range("score", "70", "80.5"));
+ assertThat(spec.getColumn()).isEqualTo(FormFilterOperators.Column.NUM);
+ assertThat(spec.getNumFrom()).isEqualByComparingTo(new BigDecimal("70"));
+ assertThat(spec.getNumTo()).isEqualByComparingTo(new BigDecimal("80.5"));
+
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("score"), value("score", "高分")))
+ .isInstanceOf(BizException.class).hasMessageContaining("不是数值");
+ }
+
+ @Test
+ @DisplayName("单值=两端同值的闭区间（value 与 from/to 两种写法都收，SQL 侧只有 between 一条分支）")
+ void singleValueCollapsesToEqualBounds() {
+ FormFilterOperators.Spec number = FormFilterOperators.resolve(field("score"), value("score", "90"));
+ assertThat(number.getKind()).isEqualTo(FormFilterOperators.Kind.EQ);
+ assertThat(number.getNumFrom()).isEqualByComparingTo(number.getNumTo());
+
+ FormFilterOperators.Spec onlyTo = FormFilterOperators.resolve(field("score"), to("score", "90"));
+ assertThat(onlyTo.getNumFrom()).isEqualByComparingTo("90");
+ assertThat(onlyTo.getNumTo()).isEqualByComparingTo("90");
+ }
+
+ @Test
+ @DisplayName("选项类只认 value、文本类只认 value：给 from/to 而不给 value 一律拒（形态不匹配不猜）")
+ void shapeMismatchIsRejected() {
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("grade"), to("grade", "g2")))
+ .isInstanceOf(BizException.class).hasMessageContaining("筛选值不能为空");
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("name"), to("name", null)))
+ .hasMessageContaining("筛选值不能为空");
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("score"), to("score", null)))
+ .hasMessageContaining("from/to");
+ }
+
+ @Test
+ @DisplayName("P28：附件类型没有检索算子，按它筛选被点名拒绝（不拿 fileName 冒充可筛值）")
+ void attachmentHasNoOperator() {
+ assertThatThrownBy(() -> FormFilterOperators.resolve(field("cert"), value("cert", "a.jpg")))
+ .isInstanceOf(BizException.class)
+ .hasMessageContaining("无检索算子");
+ }
+
+ /** 候选集里的字段=可筛字段（filterableFields 的排除面在 FormSchemaValidator 侧，这里断言两处一致） */
+ @Test
+ @DisplayName("可筛候选集=searchable 且非附件类（P28 在候选生成处的落点）")
+ void filterableCandidatesExcludeAttachmentTypes() {
+ Map candidates = FormSchemaValidator.filterableFields(SCHEMA);
+ assertThat(candidates.keySet()).contains("name", "grade", "subjects", "score", "birthday")
+ .doesNotContain("cert");
+ assertThat(FormSchemaValidator.searchableKeys(SCHEMA)).contains("cert"); // 索引侧口径不变（只 warn 不写行）
+ }
+
+ private static JsonNode field(String key) {
+ return FormSchemaValidator.fieldsByKeys(SCHEMA).get(key);
+ }
+
+ private static ReadModels.FilterItem item(String key) {
+ ReadModels.FilterItem item = new ReadModels.FilterItem();
+ item.setKey(key);
+ return item;
+ }
+
+ private static ReadModels.FilterItem value(String key, String value) {
+ ReadModels.FilterItem item = item(key);
+ item.setValue(value);
+ return item;
+ }
+
+ /** 只给上界（from=null）：解析成两端同值的闭区间 */
+ private static ReadModels.FilterItem to(String key, String to) {
+ ReadModels.FilterItem item = item(key);
+ item.setTo(to);
+ return item;
+ }
+
+ private static ReadModels.FilterItem range(String key, String from, String to) {
+ ReadModels.FilterItem item = item(key);
+ item.setFrom(from);
+ item.setTo(to);
+ return item;
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/common/FormValueSchemaBuilderTest.java b/src/test/java/com/yunhai/formcenter/common/FormValueSchemaBuilderTest.java
new file mode 100644
index 0000000..d7b3a49
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/common/FormValueSchemaBuilderTest.java
@@ -0,0 +1,121 @@
+package com.yunhai.formcenter.common;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * 机读值形状生成单测（契约 §4：schema 读接口每字段附 {@code valueSchema}，消费方可用任意
+ * JSON Schema 校验器对齐；V1 的"任取一类控件按示例构造答卷，后端接受"的机读侧依据）。
+ *
+ * 刻意只测形状、不测实现细节：类型、enum 来自内联 options、日期带 format、
+ * 附件对象是 {@code {id,fileName,key}} 三件且 {@code additionalProperties:false}（值里绝不含 URL，V24），
+ * 契约没写的约束（multipleOf/uniqueItems）不出现——发明了就是对外承诺。
+ */
+@DisplayName("FormValueSchemaBuilder - 契约 §4 valueSchema 形状（V1）")
+class FormValueSchemaBuilderTest {
+
+ private static final String SCHEMA = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"reason\",\"type\":\"textarea\",\"label\":\"申报理由\",\"maxLength\":1000},"
+ + "{\"key\":\"phone\",\"type\":\"phone\",\"label\":\"联系电话\",\"pattern\":\"^\\\\d{11}$\"},"
+ + "{\"key\":\"score\",\"type\":\"number\",\"label\":\"分数\",\"min\":0,\"max\":100,\"precision\":1},"
+ + "{\"key\":\"birthday\",\"type\":\"date\",\"label\":\"出生日期\"},"
+ + "{\"key\":\"grade\",\"type\":\"select\",\"label\":\"年级\",\"required\":true,"
+ + "\"options\":[{\"label\":\"高二\",\"value\":\"g2\"},{\"label\":\"高三\",\"value\":\"g3\"}]},"
+ + "{\"key\":\"subjects\",\"type\":\"checkbox\",\"label\":\"获奖学科\","
+ + "\"options\":[{\"label\":\"数学\",\"value\":\"math\"},{\"label\":\"物理\",\"value\":\"phy\"}]},"
+ + "{\"key\":\"cert\",\"type\":\"image\",\"label\":\"证书照片\",\"accept\":\".jpg\","
+ + "\"maxSize\":10,\"maxFiles\":9}"
+ + "]}]}";
+
+ @Test
+ @DisplayName("文本类=string（带 maxLength/pattern），number=number（带声明过的 min/max）")
+ void textAndNumberShapes() {
+ JsonNode root = FormValueSchemaBuilder.withValueSchemas(FormSchemaValidator.parse(SCHEMA, "x"));
+ assertThat(valueOf(root, "reason").get("type").asText()).isEqualTo("string");
+ assertThat(valueOf(root, "reason").get("maxLength").asInt()).isEqualTo(1000);
+ assertThat(valueOf(root, "phone").get("pattern").asText()).isEqualTo("^\\d{11}$");
+ JsonNode score = valueOf(root, "score");
+ assertThat(score.get("type").asText()).isEqualTo("number");
+ assertThat(score.get("minimum").asInt()).isZero();
+ assertThat(score.get("maximum").asInt()).isEqualTo(100);
+ // precision 是展示口径（四舍五入位数），不是 JSON Schema 的 multipleOf 约束——不发明
+ assertThat(score.has("multipleOf")).isFalse();
+ }
+
+ @Test
+ @DisplayName("date=string+format:date；选项类=string+enum（enum 取 value 不取 label）")
+ void dateAndOptionShapes() {
+ assertThat(valueOf(root(), "birthday").get("type").asText()).isEqualTo("string");
+ assertThat(valueOf(root(), "birthday").get("format").asText()).isEqualTo("date");
+ JsonNode grade = valueOf(root(), "grade");
+ assertThat(grade.get("type").asText()).isEqualTo("string");
+ assertThat(grade.get("enum")).extracting(JsonNode::asText).containsExactly("g2", "g3");
+
+ JsonNode subjects = valueOf(root(), "subjects");
+ assertThat(subjects.get("type").asText()).isEqualTo("array");
+ assertThat(subjects.path("items").get("type").asText()).isEqualTo("string");
+ assertThat(subjects.path("items").get("enum")).extracting(JsonNode::asText)
+ .containsExactly("math", "phy");
+ // 契约没写"不可重复"，不加 uniqueItems
+ assertThat(subjects.has("uniqueItems")).isFalse();
+ }
+
+ @Test
+ @DisplayName("附件类=array of {id,fileName,key} 且 additionalProperties=false（值里不可能出现 URL——V24）")
+ void attachmentShapeIsTheContractTriple() {
+ JsonNode cert = valueOf(root(), "cert");
+ assertThat(cert.get("type").asText()).isEqualTo("array");
+ JsonNode file = cert.path("items");
+ assertThat(file.get("type").asText()).isEqualTo("object");
+ assertThat(file.path("properties").fieldNames()).toIterable()
+ .containsExactlyInAnyOrder("id", "fileName", "key");
+ assertThat(file.path("properties").path("id").get("type").asText()).isEqualTo("integer");
+ assertThat(file.path("required")).extracting(JsonNode::asText)
+ .containsExactly("id", "fileName", "key");
+ assertThat(file.get("additionalProperties").asBoolean()).isFalse();
+ // maxFiles 是值数组长度上限（契约 §3 每字段 ≤9 个），映射成 maxItems
+ assertThat(cert.get("maxItems").asInt()).isEqualTo(9);
+ assertThat(cert.has("maxSize")).isFalse();
+ }
+
+ @Test
+ @DisplayName("没有 options 的选项类字段不写空 enum；未知/二期类型不写 valueSchema 键")
+ void omitsWhatItCannotKnow() {
+ String schema = "{\"groups\":[{\"key\":\"g\",\"label\":\"组\",\"fields\":["
+ + "{\"key\":\"addr\",\"type\":\"address\",\"label\":\"地址\"},"
+ + "{\"key\":\"pick\",\"type\":\"radio\",\"label\":\"无选项\"}]}]}";
+ JsonNode root = FormValueSchemaBuilder.withValueSchemas(FormSchemaValidator.parse(schema, "x"));
+ JsonNode fields = root.path("groups").get(0).path("fields");
+ assertThat(fields.get(0).has("valueSchema")).isFalse(); // address 二期：不给形状
+ JsonNode valueSchema = fields.get(1).path("valueSchema");
+ assertThat(valueSchema.get("type").asText()).isEqualTo("string");
+ assertThat(valueSchema.has("enum")).isFalse(); // 无 options 不编造枚举
+ }
+
+ @Test
+ @DisplayName("入参 schema 不被改写（版本行原文逐字节冻结，V7）；加工结果是副本")
+ void inputSchemaIsNotMutated() {
+ JsonNode original = FormSchemaValidator.parse(SCHEMA, "x");
+ String before = original.toString();
+ FormValueSchemaBuilder.withValueSchemas(original);
+ assertThat(original.toString()).isEqualTo(before);
+ }
+
+ private JsonNode root() {
+ return FormValueSchemaBuilder.withValueSchemas(FormSchemaValidator.parse(SCHEMA, "x"));
+ }
+
+ private static JsonNode valueOf(JsonNode root, String fieldKey) {
+ for (JsonNode group : root.path("groups")) {
+ for (JsonNode field : group.path("fields")) {
+ if (fieldKey.equals(field.path("key").asText())) {
+ return field.path("valueSchema");
+ }
+ }
+ }
+ throw new IllegalStateException("测试 schema 里没有字段 " + fieldKey);
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/common/FormValueValidatorTest.java b/src/test/java/com/yunhai/formcenter/common/FormValueValidatorTest.java
index 3ab0187..68a5b02 100644
--- a/src/test/java/com/yunhai/formcenter/common/FormValueValidatorTest.java
+++ b/src/test/java/com/yunhai/formcenter/common/FormValueValidatorTest.java
@@ -204,15 +204,18 @@ class FormValueValidatorTest {
}
@Test
- @DisplayName("attachmentFileIds：只为附件类字段抽取引用 id（服务层据此做同校归属校验）")
- void extractsAttachmentIdsOnlyFromAttachmentFields() {
- List ids = FormValueValidator.attachmentFileIds(
+ @DisplayName("attachments：只为附件类字段抽出完整三件套（服务层按 id 定位行、再比对 key/fileName——P34）")
+ void extractsAttachmentItemsOnlyFromAttachmentFields() {
+ List files = FormValueValidator.attachments(
v("\"name\":\"张三\",\"grade\":\"g2\",\"cert\":"
+ "[{\"id\":1001,\"fileName\":\"a.jpg\",\"key\":\"k/a.jpg\"}],"
+ "\"files\":[{\"id\":1002,\"fileName\":\"b.pdf\",\"key\":\"k/b.pdf\"},"
+ "{\"id\":1003,\"fileName\":\"c.pdf\",\"key\":\"k/c.pdf\"}]"), SCHEMA);
- assertThat(ids).containsExactly(1001L, 1002L, 1003L);
- assertThat(FormValueValidator.attachmentFileIds(
+ assertThat(files).hasSize(3);
+ assertThat(files).extracting(node -> node.path("id").longValue()).containsExactly(1001L, 1002L, 1003L);
+ assertThat(files).extracting(node -> node.path("key").asText())
+ .containsExactly("k/a.jpg", "k/b.pdf", "k/c.pdf");
+ assertThat(FormValueValidator.attachments(
v("\"name\":\"张三\",\"grade\":\"g2\""), SCHEMA)).isEmpty();
}
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerAdminIT.java b/src/test/java/com/yunhai/formcenter/service/AnswerAdminIT.java
index d15fb3f..87b591e 100644
--- a/src/test/java/com/yunhai/formcenter/service/AnswerAdminIT.java
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerAdminIT.java
@@ -14,6 +14,7 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
@@ -32,6 +33,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
* 两个端点保证（本轮代码结构即证据，见 T3 报告 §1）。
*/
@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
@Transactional
@DisplayName("AnswerAdminService - 编辑/软删/改状态/批量（V29/V30/V14/V15）")
class AnswerAdminIT extends AnswerTestSupport {
@@ -66,7 +68,7 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.EditRequest edit = new AnswerModels.EditRequest();
edit.setAnswerId(answerId);
edit.setValues(json("{\"name\":\"张三改\",\"score\":88,\"remark\":\"管理员修正\"}"));
- adminService.edit(SCH, operator, edit);
+ adminService.edit(manager(operator), SCH, edit);
Answer stored = answerRepository.findByUuidAndSchId(answerId, SCH).get();
assertThat(stored.getValuesJson()).contains("张三改").contains("88");
@@ -103,7 +105,7 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.EditRequest withNewField = new AnswerModels.EditRequest();
withNewField.setAnswerId(answerId);
withNewField.setValues(json("{\"name\":\"张三\",\"score\":95.5,\"teacher\":\"李老师\"}"));
- assertThatThrownBy(() -> adminService.edit(SCH, 10001, withNewField))
+ assertThatThrownBy(() -> adminService.edit(manager(), SCH, withNewField))
.isInstanceOf(BizException.class)
.hasMessageContaining("未知字段"); // v2 的字段不凭空落在 v1 的答卷上
@@ -124,12 +126,12 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.EditRequest clearRequired = new AnswerModels.EditRequest();
clearRequired.setAnswerId(answerId);
clearRequired.setValues(json("{\"score\":95.5}"));
- assertThatThrownBy(() -> adminService.edit(SCH, 10001, clearRequired)).hasMessageContaining("必填");
+ assertThatThrownBy(() -> adminService.edit(manager(), SCH, clearRequired)).hasMessageContaining("必填");
AnswerModels.EditRequest badType = new AnswerModels.EditRequest();
badType.setAnswerId(answerId);
badType.setValues(json("{\"name\":\"张三\",\"score\":\"高分\"}"));
- assertThatThrownBy(() -> adminService.edit(SCH, 10001, badType)).hasMessageContaining("必须是数字");
+ assertThatThrownBy(() -> adminService.edit(manager(), SCH, badType)).hasMessageContaining("必须是数字");
assertThat(opLogRepository.findByAnswerIdOrderByIdAsc(rowId.getId())).isEmpty();
assertThat(answerRepository.findByUuidAndSchId(answerId, SCH).get().getValuesJson()).contains("原文");
@@ -146,7 +148,7 @@ class AnswerAdminIT extends AnswerTestSupport {
Answer stored = answerRepository.findByUuidAndSchId(answerId, SCH).get();
assertThat(indexService.rowsOf(stored.getId())).isNotEmpty();
- adminService.softDelete(SCH, 10001, answerId);
+ adminService.softDelete(manager(), SCH, answerId);
Answer after = answerRepository.findByUuidAndSchId(answerId, SCH).get();
assertThat(after.getIsDeleted()).isEqualTo(1);
@@ -156,7 +158,7 @@ class AnswerAdminIT extends AnswerTestSupport {
// 留痕与答卷行都还在：只有软删标记，没有任何物理删除路径
assertThat(answerRepository.findById(after.getId())).isPresent();
- assertThatThrownBy(() -> adminService.softDelete(SCH, 10001, answerId))
+ assertThatThrownBy(() -> adminService.softDelete(manager(), SCH, answerId))
.isInstanceOf(BizException.class).hasMessageContaining("已删除");
}
@@ -167,14 +169,14 @@ class AnswerAdminIT extends AnswerTestSupport {
String uuid = publishForm(code, SCHEMA);
String answerId = answerService.submit(plainUser(3), submit(code, VALUES)).getAnswerId();
- assertThatThrownBy(() -> adminService.softDelete(OTHER_SCH, 10001, answerId))
+ assertThatThrownBy(() -> adminService.softDelete(manager(), OTHER_SCH, answerId))
.isInstanceOf(BizException.class).hasMessageContaining("答卷不存在");
defService.softDelete(SCH, uuid);
AnswerModels.EditRequest edit = new AnswerModels.EditRequest();
edit.setAnswerId(answerId);
edit.setValues(json("{\"name\":\"删表后仍可修正\",\"score\":60}"));
- adminService.edit(SCH, 10001, edit);
+ adminService.edit(manager(), SCH, edit);
assertThat(answerRepository.findByUuidAndSchId(answerId, SCH).get().getValuesJson()).contains("删表后仍可修正");
}
@@ -236,10 +238,10 @@ class AnswerAdminIT extends AnswerTestSupport {
// 控制器走的就是这一行：无管理权的填表人到不了 service
for (BoaUser submitter : Arrays.asList(plainUser(3), plainUser(1))) {
- assertThatThrownBy(() -> adminGuard.requireAdmin(submitter, null))
- .isInstanceOf(BizException.class).hasMessageContaining("无表单管理权限");
+ assertThatThrownBy(() -> adminGuard.requireAdmin(submitter, null, FormAdminGuard.MODULE_DATA_MANAGE))
+ .isInstanceOf(BizException.class).hasMessageContaining("无该模块权限");
}
- assertThat(adminGuard.requireAdmin(adminUser(), null)).isEqualTo(SCH);
+ assertThat(adminGuard.requireAdmin(adminUser(), null, FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
}
// ==================== 批量 ====================
@@ -259,7 +261,7 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.BatchRequest batch = new AnswerModels.BatchRequest();
batch.setAnswerIds(Arrays.asList(first, "00000000000000000000000000000000", second));
- List results = adminService.batchChangeStatus(SCH, 10001, withStatus(batch));
+ List results = adminService.batchChangeStatus(manager(), SCH, withStatus(batch));
assertThat(results).hasSize(3);
assertThat(results.stream().filter(AnswerModels.BatchItemView::getSuccess).count()).isEqualTo(2);
@@ -284,12 +286,12 @@ class AnswerAdminIT extends AnswerTestSupport {
void batchInputGuards() {
AnswerModels.BatchRequest empty = new AnswerModels.BatchRequest();
empty.setAnswerIds(java.util.Collections.emptyList());
- assertThatThrownBy(() -> adminService.batchSoftDelete(SCH, 10001, empty))
+ assertThatThrownBy(() -> adminService.batchSoftDelete(manager(), SCH, empty))
.isInstanceOf(BizException.class).hasMessageContaining("至少要选一条");
AnswerModels.BatchRequest tooMany = new AnswerModels.BatchRequest();
tooMany.setAnswerIds(java.util.Collections.nCopies(AnswerAdminService.MAX_BATCH_SIZE + 1, "x"));
- assertThatThrownBy(() -> adminService.batchSoftDelete(SCH, 10001, tooMany))
+ assertThatThrownBy(() -> adminService.batchSoftDelete(manager(), SCH, tooMany))
.hasMessageContaining("单次上限");
}
@@ -303,7 +305,7 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.BatchRequest batch = new AnswerModels.BatchRequest();
batch.setAnswerIds(Arrays.asList(first, second));
- assertThat(adminService.batchSoftDelete(SCH, 10001, batch))
+ assertThat(adminService.batchSoftDelete(manager(), SCH, batch))
.extracting(AnswerModels.BatchItemView::getSuccess).containsOnly(true);
for (String id : Arrays.asList(first, second)) {
@@ -321,7 +323,7 @@ class AnswerAdminIT extends AnswerTestSupport {
AnswerModels.ChangeStatusRequest req = new AnswerModels.ChangeStatusRequest();
req.setAnswerId(answerId);
req.setStatus(status);
- adminService.changeStatus(SCH, 10001, req);
+ adminService.changeStatus(manager(), SCH, req);
}
private AnswerModels.BatchRequest withStatus(AnswerModels.BatchRequest batch) {
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerConcurrencyIT.java b/src/test/java/com/yunhai/formcenter/service/AnswerConcurrencyIT.java
index 54cdd26..b3635fd 100644
--- a/src/test/java/com/yunhai/formcenter/service/AnswerConcurrencyIT.java
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerConcurrencyIT.java
@@ -16,6 +16,7 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
import org.springframework.transaction.support.TransactionTemplate;
import java.util.ArrayList;
@@ -33,6 +34,7 @@ import static org.assertj.core.api.Assertions.assertThat;
* 因此 {@code @AfterEach} 必须定点清理本类自建的数据（租户域 990401，不与其它 IT 交叉）。
*/
@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
@DisplayName("AnswerService - 并发兜底（V32：唯一键才是并发下的裁判）")
class AnswerConcurrencyIT extends AnswerTestSupport {
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerExportIT.java b/src/test/java/com/yunhai/formcenter/service/AnswerExportIT.java
new file mode 100644
index 0000000..bb127fe
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerExportIT.java
@@ -0,0 +1,189 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.FormFile;
+import com.yunhai.formcenter.model.ReadModels;
+import com.yunhai.formcenter.repository.FormFileRepository;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.model.BoaUser;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.io.ByteArrayOutputStream;
+import java.time.LocalDateTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * 导出集成测试（真实 MySQL；自验项 V37）。
+ *
+ * V37 的四个断言点逐条对上：范围=单表单 + 可选筛选；行数与该数据范围下的总数一致
+ * （不是列表当页）；选项列显 label、附件列为文件名；受限身份导出 ⊆ 其可见集
+ * （与 V27 同一构造器——这里断言的是"文件里真的只有那几行"，而不是服务返回的计数）。
+ */
+@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
+@Transactional
+@DisplayName("答卷导出 - easyexcel 流式（V37）")
+class AnswerExportIT extends AnswerTestSupport {
+
+ private static final String FORM = "t4_export";
+
+ /** grade 是选项类（存 value 出 label）、subjects 是多选（出 label 且按 options 定义序）、cert 是附件（出 fileName） */
+ private static final String SCHEMA = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"name\",\"label\":\"姓名\",\"type\":\"text\",\"required\":true,\"searchable\":true},"
+ + "{\"key\":\"grade\",\"label\":\"年级\",\"type\":\"select\",\"required\":true,\"searchable\":true,"
+ + "\"options\":[{\"label\":\"高二年级\",\"value\":\"g2\"},{\"label\":\"高三年级\",\"value\":\"g3\"}]},"
+ + "{\"key\":\"subjects\",\"label\":\"获奖学科\",\"type\":\"checkbox\",\"searchable\":true,"
+ + "\"options\":[{\"label\":\"数学\",\"value\":\"math\"},{\"label\":\"物理\",\"value\":\"phy\"}]},"
+ + "{\"key\":\"cert\",\"label\":\"证书照片\",\"type\":\"image\"}"
+ + "]}]}";
+
+ @Autowired
+ private AnswerExportService exportService;
+
+ @Autowired
+ private AnswerReadService readService;
+
+ @Autowired
+ private FormFileRepository fileRepository;
+
+ @Test
+ @DisplayName("V37：行数=该范围下的总数（非列表当页）；列序=身份列 + schema 展示序")
+ void exportCountEqualsScopeTotal() {
+ BoaUser admin = manager();
+ String formUuid = seed(admin, 25);
+
+ ReadModels.QueryRequest req = new ReadModels.QueryRequest();
+ req.setFormUuid(formUuid);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ long written = exportService.export(admin, SCH, req, out);
+
+ assertThat(written).as("导出行数=范围内的总数，与列表当页大小无关（页大小 20，数据 25 行）")
+ .isEqualTo(25L);
+ List> rows = XlsxReader.dataRows(out.toByteArray());
+ assertThat(rows).hasSize(25);
+ assertThat(XlsxReader.headers(out.toByteArray()))
+ .containsExactly("答卷ID", "报名号", "状态", "提交人ID", "被代填人ID", "提交时间",
+ "姓名（name）", "年级（grade）", "获奖学科（subjects）", "证书照片（cert）");
+ // 第一段不取值文档，导出按批推进游标：行数与 uuid 集合都应与列表全量一致（同构造器的直接体现）
+ ReadModels.ListRequest list = new ReadModels.ListRequest();
+ list.setFormUuid(formUuid);
+ list.setSize(50);
+ assertThat(readService.list(admin, SCH, list).getRows()).hasSize(25);
+ }
+
+ @Test
+ @DisplayName("V37 内容正确性：选项列显 label、多选按 options 定义序（不按勾选序）、附件列显 fileName")
+ void optionAndAttachmentCellsAreRendered() {
+ BoaUser admin = manager();
+ String formUuid = seed(admin, 1);
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ exportService.export(admin, SCH, request(formUuid), out);
+
+ Map row = XlsxReader.dataRows(out.toByteArray()).get(0);
+ assertThat(row.get(7)).as("select 列显 label 不是 value").isEqualTo("高二年级");
+ assertThat(row.get(8)).as("多选存 [\"phy\",\"math\"]，出\"数学、物理\"（定义序，契约 §3）")
+ .isEqualTo("数学、物理");
+ assertThat(row.get(9)).as("附件列只出文件名（值里本来就没有 URL，V24）").isEqualTo("奖状.jpg");
+ assertThat(row.get(0)).as("第一列是答卷 uuid，不是库内 id").hasSize(32);
+ assertThat(out.toByteArray().length).isPositive();
+ }
+
+ @Test
+ @DisplayName("V37/V27：受限身份导出 ⊆ 其可见集——教师只导得出自己那几条，且与列表可见 uuid 集合完全一致")
+ void exportIsScopeBoundPerIdentity() {
+ BoaUser admin = manager();
+ String formUuid = seed(admin, 6);
+
+ BoaUser teacher = user(ReadFixture.TEACHER_1, SCH, 1);
+ ByteArrayOutputStream teacherOut = new ByteArrayOutputStream();
+ long teacherRows = exportService.export(teacher, SCH, request(formUuid), teacherOut);
+
+ ReadModels.ListRequest list = new ReadModels.ListRequest();
+ list.setFormUuid(formUuid);
+ list.setSize(50);
+ List visible = new java.util.ArrayList<>();
+ readService.list(teacher, SCH, list).getRows().forEach(r -> visible.add(r.getAnswerId()));
+
+ assertThat(teacherRows).isEqualTo(visible.size());
+ assertThat(XlsxReader.firstColumn(teacherOut.toByteArray())).containsExactlyElementsOf(visible);
+ assertThat(visible).hasSize(3).allMatch(id -> id != null);
+
+ // 没有任何本人数据的身份：导出是"只有表头的合法文件"，不是坏文件、也不是全校
+ BoaUser outsider = user(ReadFixture.BUREAU_LEADER, SCH, 5);
+ ByteArrayOutputStream empty = new ByteArrayOutputStream();
+ assertThat(exportService.export(outsider, SCH, request(formUuid), empty)).isZero();
+ assertThat(XlsxReader.dataRows(empty.toByteArray())).isEmpty();
+ assertThat(XlsxReader.headers(empty.toByteArray())).isNotEmpty();
+ }
+
+ @Test
+ @DisplayName("导出同样吃筛选条件（单表单+可选筛选）；条件不合法与列表一样被拒，不静默导全量")
+ void exportHonoursFiltersAndRejectsBadOnes() {
+ BoaUser admin = manager();
+ String formUuid = seed(admin, 6);
+
+ ReadModels.QueryRequest filtered = request(formUuid);
+ ReadModels.FilterItem grade = new ReadModels.FilterItem();
+ grade.setKey("grade");
+ grade.setValue("g3");
+ filtered.setFilters(Arrays.asList(grade));
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ assertThat(exportService.export(admin, SCH, filtered, out)).isEqualTo(3L);
+ assertThat(XlsxReader.dataRows(out.toByteArray()))
+ .extracting(row -> row.get(7)).containsOnly("高三年级");
+
+ ReadModels.QueryRequest bad = request(formUuid);
+ ReadModels.FilterItem unknown = new ReadModels.FilterItem();
+ unknown.setKey("not_searchable");
+ unknown.setValue("x");
+ bad.setFilters(Arrays.asList(unknown));
+ assertThatThrownBy(() -> exportService.export(admin, SCH, bad, new ByteArrayOutputStream()))
+ .isInstanceOf(BizException.class).hasMessageContaining("不可作为筛选条件");
+ }
+
+ // ==================== 数据准备 ====================
+
+ /**
+ * 建表单并发布，管理员身份写 {@code total} 条答卷，其中前 3 条由教师1 提交（范围用例的"他可见集"）。
+ *
+ * @return 表单 uuid
+ */
+ private String seed(BoaUser admin, int total) {
+ String formUuid = publishForm(FORM, SCHEMA);
+ FormFile file = new FormFile();
+ file.setSchId(SCH);
+ file.setFileName("奖状.jpg");
+ file.setStoreKey("form/2026/10/" + newIdemKey() + ".jpg");
+ file.setFileSize(1024L);
+ file.setExt("jpg");
+ file.setCreateTime(LocalDateTime.now());
+ file.setUpdateTime(LocalDateTime.now());
+ file = fileRepository.save(file);
+
+ BoaUser teacher = user(ReadFixture.TEACHER_1, SCH, 1);
+ for (int i = 0; i < total; i++) {
+ String grade = i % 2 == 0 ? "g2" : "g3";
+ String values = "{\"name\":\"学生" + i + "\",\"grade\":\"" + grade + "\","
+ + "\"subjects\":[\"phy\",\"math\"],"
+ + "\"cert\":[{\"id\":" + file.getId() + ",\"fileName\":\"" + file.getFileName()
+ + "\",\"key\":\"" + file.getStoreKey() + "\"}]}";
+ answerService.submit(i < 3 ? teacher : admin, submit(FORM, values));
+ }
+ return formUuid;
+ }
+
+ private ReadModels.QueryRequest request(String formUuid) {
+ ReadModels.QueryRequest req = new ReadModels.QueryRequest();
+ req.setFormUuid(formUuid);
+ return req;
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerReadIT.java b/src/test/java/com/yunhai/formcenter/service/AnswerReadIT.java
new file mode 100644
index 0000000..e297446
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerReadIT.java
@@ -0,0 +1,520 @@
+package com.yunhai.formcenter.service;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.read.ListAppender;
+import com.yunhai.formcenter.entity.Answer;
+import com.yunhai.formcenter.enums.FormEnums.DataScope;
+import com.yunhai.formcenter.model.AnswerModels;
+import com.yunhai.formcenter.model.FormModels;
+import com.yunhai.formcenter.model.ReadModels;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.model.BoaUser;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * 数据面读路径集成测试（真实 MySQL；自验项 V9 / V11 / V23 / V27 / V42 +
+ * V30 的读侧半边、V39 的范围半边、P25 遮蔽用例、方案 §5.5 铁律①②取证）。
+ *
+ * 数据集见 {@link ReadFixture}：两表单（面向学生/面向教师）× 学生/教师/局领导/管理员 × 软删混合。
+ *
+ * V27/V42 的硬断言方式：对每个受限身份，把"列表可见集"当作基准集合，
+ * 统计的总数与导出的行数必须等于该集合大小、且导出的 uuid 必须子于该集合——
+ * 这是"四条读出路径共用同一个 scope 构造器"（契约 §8 红线）的可执行表达，
+ * 单独比数值大小不够（数值相等仍可能是不同的行）。
+ */
+@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
+@Transactional
+@DisplayName("数据面读路径 - 列表/详情/统计/范围（V9/V11/V23/V27/V30/V39/V42/P25）")
+class AnswerReadIT extends AnswerTestSupport {
+
+ @Autowired
+ private AnswerReadService readService;
+
+ @Autowired
+ private AnswerStatsService statsService;
+
+ @Autowired
+ private AnswerExportService exportService;
+
+ @Autowired
+ private FormAdminGuard adminGuard;
+
+ @org.springframework.beans.factory.annotation.Value("${spring.jpa.open-in-view}")
+ private Boolean openInView;
+
+ // ==================== 铁律①：两段式，第一段绝不 SELECT values_json ====================
+
+ @Test
+ @DisplayName("铁律①取证：列表第一段只 select id（SQL 里不出现 values_json），第二段才按当页 id 批量取值文档")
+ void listIsTwoPhaseAndLocatorNeverSelectsValuesColumn() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+
+ List sqls = captureAnswerSqls(() -> readService.list(manager(), SCH, listRequest(rows.formAUuid)));
+
+ List answerReads = sqls.stream().filter(sql -> sql.contains("from answer ")).collect(Collectors.toList());
+ assertThat(answerReads).as("列表至少有一次 answer 表访问").isNotEmpty();
+ String locator = answerReads.get(0);
+ assertThat(locator).as("第一段：定位当页 id").doesNotContain("values_json").contains("order by");
+ assertThat(answerReads).anyMatch(sql -> sql.contains("values_json")); // 第二段才取文档
+ }
+
+ // ==================== 铁律②：keyset 翻页 ====================
+
+ @Test
+ @DisplayName("铁律②：按提交时间序 keyset 翻页不重不漏；游标指向不可见答卷时被拒（不拿游标探测他人数据）")
+ void keysetPagesWithoutOverlapAndCursorIsScopeBound() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser admin = manager();
+
+ Set paged = new LinkedHashSet<>();
+ String cursor = null;
+ int pages = 0;
+ while (pages < 10) {
+ ReadModels.ListRequest req = listRequest(rows.formAUuid);
+ req.setCursor(cursor);
+ req.setSize(2);
+ ReadModels.ListView page = readService.list(admin, SCH, req);
+ if (page.getRows().isEmpty()) {
+ break;
+ }
+ for (ReadModels.RowView row : page.getRows()) {
+ assertThat(paged.add(row.getAnswerId())).as("翻页出现重复行：游标未正确推进").isTrue();
+ }
+ cursor = page.getNextCursor();
+ pages++;
+ }
+ assertThat(pages).as("五行未删数据按 size=2 应翻 3 页").isEqualTo(3);
+ assertThat(paged).containsExactlyInAnyOrder(rows.student1Self, rows.student2Self,
+ rows.proxyForStudent1, rows.teacher1Self, rows.teacher2Self);
+
+ // 游标用别人范围内的 uuid：不可见即拒（PARAM_ERROR，而不是静默从头开始）
+ String foreign = rows.teacher1Self;
+ ReadModels.ListRequest probe = listRequest(rows.formAUuid);
+ probe.setCursor(foreign);
+ probe.setSize(2);
+ BoaUser student1 = fixture.student1();
+ assertThatThrownBy(() -> readService.list(student1, SCH, probe))
+ .isInstanceOf(BizException.class).hasMessageContaining("游标不可用");
+ }
+
+ // ==================== V27/V42：范围贯穿，统计与导出 ⊆ 列表可见集 ====================
+
+ @Test
+ @DisplayName("V42 矩阵生效：管理员=全部、教师=仅本人提交、学生=关于我（含老师代填那条）、局领导=仅本人提交")
+ void matrixResolvesPerContractSectionEight() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+
+ assertThat(visibleIds(fixture, manager(), rows.formAUuid))
+ .containsExactlyInAnyOrder(rows.student1Self, rows.student2Self, rows.proxyForStudent1,
+ rows.teacher1Self, rows.teacher2Self);
+ // 教师×面向学生：一期实际生效=仅本人提交（方案 §6.4 表格明示，防被当 bug 报）
+ assertThat(visibleIds(fixture, fixture.teacher1(), rows.formAUuid))
+ .containsExactly(rows.teacher1Self);
+ // 学生×面向学生=关于我：自填那条 subject 为空看不见，老师代填的看得见（契约 §6.3 两键分立的直接体现）
+ assertThat(visibleIds(fixture, fixture.student1(), rows.formAUuid))
+ .containsExactly(rows.proxyForStudent1);
+ // 局领导(5) 回落仅本人提交：他没填过 → 空集（不是全部）
+ assertThat(visibleIds(fixture, fixture.bureauLeader(), rows.formAUuid)).isEmpty();
+ }
+
+ @Test
+ @DisplayName("V42 扩展位：给组授权 customId=fc:scope:all 的模块行后，该教师范围升级为全部（与矩阵同一条解析）")
+ void scopeAllAnchorUpgradesTeacher() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser teacher = fixture.teacher1();
+ assertThat(visibleIds(fixture, teacher, rows.formAUuid)).containsExactly(rows.teacher1Self);
+
+ moduleTree.grantCustomId(ReadFixture.TEACHER_1, DataScopeService.SCOPE_ALL_CUSTOM_ID);
+ ReadModels.ListView upgraded = readService.list(teacher, SCH, listRequest(rows.formAUuid));
+ assertThat(upgraded.getScopes()).containsExactly(DataScope.ALL);
+ assertThat(upgraded.getRows()).hasSize(5);
+ }
+
+ @Test
+ @DisplayName("V27/V42 硬断言：每个受限身份的统计总数与导出行数 =其列表可见集大小，导出 uuid ⊆ 可见集")
+ void statsAndExportAreSubsetsOfListForEveryIdentity() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+
+ List identities = Arrays.asList(manager(), fixture.teacher1(), fixture.teacher2(),
+ fixture.student1(), fixture.student2(), fixture.bureauLeader());
+ for (BoaUser user : identities) {
+ Set list = visibleIds(fixture, user, rows.formAUuid);
+
+ ReadModels.QueryRequest stats = new ReadModels.QueryRequest();
+ stats.setFormUuid(rows.formAUuid);
+ stats.setGroupByField("grade");
+ ReadModels.StatsView view = statsService.stats(user, SCH, stats);
+ assertThat(view.getTotal()).as("统计总数必须等于列表可见行数（" + scopeName(user) + "）")
+ .isEqualTo(list.size());
+ long statusSum = view.getByStatus().stream().mapToLong(ReadModels.CountItem::getCount).sum();
+ assertThat(statusSum).as("按状态分桶求和也必须等于总数").isEqualTo(list.size());
+ long gradeSum = view.getByField().isEmpty() ? 0L
+ : view.getByField().get(0).getItems().stream().mapToLong(ReadModels.CountItem::getCount).sum();
+ assertThat(gradeSum).as("按字段分组求和 ≤ 总数（一答卷多值也只计一次，distinct）").isLessThanOrEqualTo(list.size());
+
+ java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
+ ReadModels.QueryRequest exportReq = new ReadModels.QueryRequest();
+ exportReq.setFormUuid(rows.formAUuid);
+ long exported = exportService.export(user, SCH, exportReq, out);
+ assertThat(exported).as("导出行数=该范围下的总数（非列表当页）").isEqualTo(list.size());
+ assertThat(XlsxReader.firstColumn(out.toByteArray()))
+ .as("导出内容必须 ⊆ 列表可见集").isSubsetOf(list);
+ }
+ }
+
+ // ==================== V30 读侧半边 ====================
+
+ @Test
+ @DisplayName("V30：软删答卷在列表/详情/统计/导出四条路径一律不可见")
+ void softDeletedAnswerIsInvisibleOnAllFourPaths() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser admin = manager();
+
+ assertThat(visibleIds(fixture, admin, rows.formAUuid)).doesNotContain(rows.softDeleted);
+
+ assertThatThrownBy(() -> readService.detail(admin, SCH, rows.softDeleted))
+ .isInstanceOf(BizException.class).hasMessageContaining("不存在或已删除");
+
+ ReadModels.QueryRequest stats = new ReadModels.QueryRequest();
+ stats.setFormUuid(rows.formAUuid);
+ assertThat(statsService.stats(admin, SCH, stats).getTotal()).isEqualTo(5L);
+
+ java.io.ByteArrayOutputStream out = new java.io.ByteArrayOutputStream();
+ ReadModels.QueryRequest exportReq = new ReadModels.QueryRequest();
+ exportReq.setFormUuid(rows.formAUuid);
+ assertThat(exportService.export(admin, SCH, exportReq, out)).isEqualTo(5L);
+ assertThat(XlsxReader.firstColumn(out.toByteArray())).doesNotContain(rows.softDeleted);
+ }
+
+ // ==================== V9：升版声明 searchable 后旧答卷可按新字段筛 ====================
+
+ @Test
+ @DisplayName("V9：新版本给 advisor 声明 searchable 后，旧答卷可按它筛选（全程无 DDL；靠发布补建索引行）")
+ void searchableFieldAddedInV2FiltersOldAnswers() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser admin = manager();
+
+ // v1：advisor 不在筛选候选里（未声明 searchable）
+ assertThat(readService.filterFields(SCH, rows.formAUuid))
+ .extracting(ReadModels.FilterFieldView::getKey)
+ .contains("name", "grade", "score", "birthday")
+ .doesNotContain("advisor");
+
+ fixture.upgradeToV2(rows.formAUuid);
+
+ List candidates = readService.filterFields(SCH, rows.formAUuid)
+ .stream().map(ReadModels.FilterFieldView::getKey).collect(Collectors.toList());
+ assertThat(candidates).as("升版后候选集里出现 advisor（无 DDL，纯 schema 声明）").contains("advisor");
+
+ // 三条 v1 期写的答卷（advisor=李老师）现在能按新字段筛出来——索引行是发布时补建的
+ Set hit = visibleIdsWithFilter(fixture, admin, rows.formAUuid,
+ filter("advisor", "李", null, null));
+ assertThat(hit).containsExactlyInAnyOrder(rows.student1Self, rows.proxyForStudent1);
+ assertThat(visibleIdsWithFilter(fixture, admin, rows.formAUuid, filter("advisor", "张老师", null, null)))
+ .containsExactlyInAnyOrder(rows.teacher1Self, rows.teacher2Self);
+ }
+
+ @Test
+ @DisplayName("P28：附件字段勾了 searchable 也不进筛选候选（无检索算子），按它筛选被拒")
+ void attachmentFieldsAreNotFilterable() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+
+ assertThat(readService.filterFields(SCH, rows.formAUuid))
+ .extracting(ReadModels.FilterFieldView::getKey).doesNotContain("cert");
+
+ ReadModels.ListRequest req = listRequest(rows.formAUuid);
+ req.setFilters(Arrays.asList(filter("cert", "x", null, null)));
+ assertThatThrownBy(() -> readService.list(manager(), SCH, req))
+ .isInstanceOf(BizException.class).hasMessageContaining("不可作为筛选条件");
+ }
+
+ @Test
+ @DisplayName("V3/V4：算子按类型收敛——选项等值、文本前缀、数值与日期区间在 SQL 层完成；未知 key 拒")
+ void operatorsAreTypeBound() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadModels.FilterFieldView grade = null;
+ ReadFixture.Rows rows = fixture.seed(manager());
+ for (ReadModels.FilterFieldView field : readService.filterFields(SCH, rows.formAUuid)) {
+ if ("grade".equals(field.getKey())) {
+ grade = field;
+ }
+ }
+ assertThat(grade.getOperator()).isEqualTo("EQ");
+ assertThat(readService.filterFields(SCH, rows.formAUuid))
+ .filteredOn(f -> "name".equals(f.getKey())).extracting(ReadModels.FilterFieldView::getOperator)
+ .containsExactly("PREFIX");
+ assertThat(readService.filterFields(SCH, rows.formAUuid))
+ .filteredOn(f -> "birthday".equals(f.getKey())).extracting(ReadModels.FilterFieldView::getOperator)
+ .containsExactly("RANGE");
+
+ // 等值：选项存 value，展示 label 变了也不影响筛选（V2 同族）
+ assertThat(visibleIdsWithFilter(fixture, manager(), rows.formAUuid, filter("grade", "g2", null, null)))
+ .containsExactlyInAnyOrder(rows.student1Self, rows.proxyForStudent1, rows.teacher2Self);
+ // 前缀模糊（且不是 LIKE 注入：传 "%" 不会命中全部）
+ assertThat(visibleIdsWithFilter(fixture, manager(), rows.formAUuid, filter("name", "张", null, null)))
+ .containsExactlyInAnyOrder(rows.student1Self, rows.proxyForStudent1);
+ assertThat(visibleIdsWithFilter(fixture, manager(), rows.formAUuid, filter("name", "%", null, null)))
+ .isEmpty();
+ // 数值区间：70~80 含两端
+ assertThat(visibleIdsWithFilter(fixture, manager(), rows.formAUuid, range("score", "70", "80")))
+ .containsExactlyInAnyOrder(rows.student2Self, rows.proxyForStudent1);
+ // 日期区间按日期比，不是字典序（V4：2010-03-09 落在 2010-01-01~2010-06-01 内）
+ assertThat(visibleIdsWithFilter(fixture, manager(), rows.formAUuid,
+ range("birthday", "2010-01-01", "2010-06-01")))
+ .containsExactlyInAnyOrder(rows.student1Self, rows.proxyForStudent1, rows.teacher2Self);
+
+ ReadModels.ListRequest unknown = listRequest(rows.formAUuid);
+ unknown.setFilters(Arrays.asList(filter("remark_not_exists", "x", null, null)));
+ assertThatThrownBy(() -> readService.list(manager(), SCH, unknown))
+ .isInstanceOf(BizException.class).hasMessageContaining("未声明 searchable");
+
+ ReadModels.ListRequest badShape = listRequest(rows.formAUuid);
+ badShape.setFilters(Arrays.asList(filter("grade", null, "g2", null)));
+ assertThatThrownBy(() -> readService.list(manager(), SCH, badShape))
+ .isInstanceOf(BizException.class).hasMessageContaining("筛选值不能为空");
+ }
+
+ // ==================== V11：统计三件事 ====================
+
+ @Test
+ @DisplayName("V11：统计返回总数/按状态/按字段分组（选项桶给 label，前端不做聚合）")
+ void statsReturnsTotalStatusAndFieldGroups() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser admin = manager();
+
+ ReadModels.QueryRequest req = new ReadModels.QueryRequest();
+ req.setFormUuid(rows.formAUuid);
+ req.setGroupByField("grade");
+ ReadModels.StatsView view = statsService.stats(admin, SCH, req);
+
+ assertThat(view.getTotal()).isEqualTo(5L);
+ assertThat(view.getByStatus()).hasSize(1);
+ assertThat(view.getByStatus().get(0).getValue()).isEqualTo("pending");
+ assertThat(view.getByStatus().get(0).getLabel()).isEqualTo("待处理");
+ assertThat(view.getByField()).hasSize(1);
+ assertThat(view.getByField().get(0).getKey()).isEqualTo("grade");
+ assertThat(view.getByField().get(0).getItems())
+ .extracting(ReadModels.CountItem::getValue, ReadModels.CountItem::getLabel,
+ ReadModels.CountItem::getCount)
+ .containsExactlyInAnyOrder(
+ org.assertj.core.groups.Tuple.tuple("g2", "高二", 3L),
+ org.assertj.core.groups.Tuple.tuple("g3", "高三", 2L));
+
+ // 状态过滤后再统计：桶与总数一起窄化（同一构造器，不是两条查询）
+ ReadModels.QueryRequest done = new ReadModels.QueryRequest();
+ done.setFormUuid(rows.formAUuid);
+ done.setStatus("done-not-used");
+ assertThat(statsService.stats(admin, SCH, done).getTotal()).isZero();
+ }
+
+ @Test
+ @DisplayName("铁律④：统计缓存键含 form_uuid+version、短 TTL，且不按数据变更失效（新答卷落库后 TTL 内总数不变）")
+ void statsCacheIsVersionScopedAndNotInvalidatedByNewData() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ BoaUser admin = manager();
+ ReadModels.QueryRequest req = new ReadModels.QueryRequest();
+ req.setFormUuid(rows.formAUuid);
+
+ ReadModels.StatsView first = statsService.stats(admin, SCH, req);
+ assertThat(first.getTotal()).isEqualTo(5L);
+ assertThat(first.getCached()).isFalse();
+
+ fixture.submit(fixture.student1(), ReadFixture.FORM_A,
+ "{\"name\":\"新写的\",\"grade\":\"g2\",\"score\":50,\"birthday\":\"2010-05-05\","
+ + "\"advisor\":\"李老师\"}");
+
+ ReadModels.StatsView second = statsService.stats(admin, SCH, req);
+ assertThat(second.getTotal()).as("提交是高频事件，按数据变更清缓存等于没有缓存（方案 §5.5 v1.2 修正）")
+ .isEqualTo(5L);
+ assertThat(second.getCached()).isTrue();
+
+ // 但列表是实时的（缓存只覆盖统计，读数据不缓存）
+ assertThat(readService.list(admin, SCH, listRequest(rows.formAUuid)).getRows()).hasSize(6);
+
+ // 换身份（范围签名不同）不会命中同一缓存——否则管理员的全校分布就漏给教师了
+ ReadModels.StatsView teacherView = statsService.stats(fixture.teacher1(), SCH, req);
+ assertThat(teacherView.getTotal()).isEqualTo(1L);
+ }
+
+ // ==================== 详情（V5 形状 + V23） ====================
+
+ @Test
+ @DisplayName("详情：uuid 寻址、返回钉住版本的 schema 与值文档；open-in-view=false 下无懒加载异常（V23/V5）")
+ void detailReturnsPinnedSchemaAndValues() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+ assertThat(openInView).as("V23 的前提：视图外置会话是关掉的（application.yml）").isFalse();
+
+ ReadModels.DetailView view = readService.detail(manager(), SCH, rows.student1Self);
+ assertThat(view.getAnswerId()).isEqualTo(rows.student1Self);
+ assertThat(view.getVersion()).isEqualTo(1);
+ assertThat(view.getValues().path("name").asText()).isEqualTo("张三");
+ assertThat(view.getGroups().toString()).contains("指导教师").contains("\"cert\"");
+ // 对外形状里不出现库内 id（V5）：详情响应字段闭集里没有任何 *Id 数字
+ assertThat(view.getFormUuid()).isNotBlank();
+ assertThat(view.getSubmitTime()).isNotBlank();
+
+ // 升版后历史答卷的详情仍是它钉住的 v1 形状（schema 不随升版漂移）
+ fixture.upgradeToV2(rows.formAUuid);
+ ReadModels.DetailView afterUpgrade = readService.detail(manager(), SCH, rows.student1Self);
+ assertThat(afterUpgrade.getVersion()).isEqualTo(1);
+ }
+
+ @Test
+ @DisplayName("详情越权面：不在范围内=FORBIDDEN（与列表同一构造器判定），别校答卷查不到")
+ void detailIsScopeBound() {
+ ReadFixture fixture = new ReadFixture(this);
+ ReadFixture.Rows rows = fixture.seed(manager());
+
+ assertThatThrownBy(() -> readService.detail(fixture.teacher2(), SCH, rows.teacher1Self))
+ .isInstanceOf(BizException.class).hasMessageContaining("不在你的数据范围内");
+ assertThatThrownBy(() -> readService.detail(manager(), OTHER_SCH, rows.teacher1Self))
+ .isInstanceOf(BizException.class).hasMessageContaining("答卷不存在");
+ // 教师被授权数据管理模块行也改不动别人的行（V39 范围半边：批量逐条判）
+ BoaUser teacher = fixture.teacher1();
+ moduleTree.grantPaths(ReadFixture.TEACHER_1, FormAdminGuard.MODULE_DATA_MANAGE);
+ adminGuard.requireAdmin(teacher, null, FormAdminGuard.MODULE_DATA_MANAGE);
+ AnswerModels.BatchRequest batch = new AnswerModels.BatchRequest();
+ batch.setAnswerIds(Arrays.asList(rows.teacher1Self, rows.teacher2Self));
+ batch.setStatus("pending");
+ List results = adminService.batchChangeStatus(teacher, SCH, batch);
+ assertThat(results.get(0).getSuccess()).isTrue();
+ assertThat(results.get(1).getSuccess()).isFalse();
+ assertThat(results.get(1).getMsg()).contains("不在你的数据范围内");
+ }
+
+ // ==================== P25：遮蔽后的钉版溯源 ====================
+
+ @Test
+ @DisplayName("P25：平台级表单被本校同 code 表单遮蔽后，历史答卷仍按原 schema 校验/渲染（form_uuid 精确取数）")
+ void platformFormShadowedBySchoolFormStillValidatesItsOwnAnswers() {
+ String code = "t4_shadow";
+ String platformUuid = publishForm(0L, code, "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\","
+ + "\"fields\":[{\"key\":\"name\",\"label\":\"姓名\",\"type\":\"text\",\"required\":true}]}]}");
+ BoaUser student = plainUser(3);
+ String answerId = answerService.submit(student, submit(code, "{\"name\":\"平台表单时期填的\"}"))
+ .getAnswerId();
+ Answer pinned = answerRepository.findByUuidAndSchId(answerId, SCH).get();
+ assertThat(pinned.getFormUuid()).isEqualTo(platformUuid);
+ assertThat(pinned.getSchId()).isEqualTo(SCH); // 校域不变式：答卷归属仍是会话校
+
+ // 本校建同 (app_code, code) 表单并发布：遮蔽规则把填报入口指向本校表单
+ String schoolUuid = publishForm(SCH, code, "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\","
+ + "\"fields\":[{\"key\":\"schoolOnly\",\"label\":\"本校字段\",\"type\":\"text\","
+ + "\"required\":true}]}]}");
+ assertThat(schoolUuid).isNotEqualTo(platformUuid);
+
+ // 历史答卷按平台 schema 编辑成功（若按本校 schema，必填的 schoolOnly 会把它挡下）
+ AnswerModels.EditRequest edit = new AnswerModels.EditRequest();
+ edit.setAnswerId(answerId);
+ edit.setValues(json("{\"name\":\"管理员按原表修正\"}"));
+ adminService.edit(manager(), SCH, edit);
+ assertThat(answerRepository.findByUuidAndSchId(answerId, SCH).get().getValuesJson())
+ .contains("管理员按原表修正");
+
+ // 反过来：夹带本校表单才有的字段被拒——证明用的是钉住的那张表，不是当前遮蔽后的那张
+ AnswerModels.EditRequest foreign = new AnswerModels.EditRequest();
+ foreign.setAnswerId(answerId);
+ foreign.setValues(json("{\"name\":\"张三\",\"schoolOnly\":\"不该出现\"}"));
+ assertThatThrownBy(() -> adminService.edit(manager(), SCH, foreign))
+ .isInstanceOf(BizException.class).hasMessageContaining("未知字段");
+ }
+
+ // ==================== 小工具 ====================
+
+ private Set visibleIds(ReadFixture fixture, BoaUser user, String formUuid) {
+ return readService.list(user, SCH, listRequest(formUuid)).getRows().stream()
+ .map(ReadModels.RowView::getAnswerId).collect(Collectors.toCollection(LinkedHashSet::new));
+ }
+
+ private Set visibleIdsWithFilter(ReadFixture fixture, BoaUser user, String formUuid,
+ ReadModels.FilterItem filter) {
+ ReadModels.ListRequest req = listRequest(formUuid);
+ req.setSize(50);
+ req.setFilters(Arrays.asList(filter));
+ return readService.list(user, SCH, req).getRows().stream()
+ .map(ReadModels.RowView::getAnswerId).collect(Collectors.toCollection(LinkedHashSet::new));
+ }
+
+ private ReadModels.ListRequest listRequest(String formUuid) {
+ ReadModels.ListRequest req = new ReadModels.ListRequest();
+ req.setFormUuid(formUuid);
+ req.setSize(50);
+ return req;
+ }
+
+ private static ReadModels.FilterItem filter(String key, String value, String from, String to) {
+ ReadModels.FilterItem item = new ReadModels.FilterItem();
+ item.setKey(key);
+ item.setValue(value);
+ item.setFrom(from);
+ item.setTo(to);
+ return item;
+ }
+
+ private static ReadModels.FilterItem range(String key, String from, String to) {
+ return filter(key, null, from, to);
+ }
+
+ private String scopeName(BoaUser user) {
+ return "user=" + user.getId() + " roles=" + user.getRoleIds();
+ }
+
+ /** 抓 answer 表的 SQL：把 Hibernate SQL 日志临时接到内存 appender（铁律①的可执行取证） */
+ private List captureAnswerSqls(Runnable action) {
+ Logger sqlLogger = (Logger) LoggerFactory.getLogger("org.hibernate.SQL");
+ Level previous = sqlLogger.getLevel();
+ ListAppender appender = new ListAppender<>();
+ appender.start();
+ sqlLogger.addAppender(appender);
+ sqlLogger.setLevel(Level.DEBUG);
+ List captured = new ArrayList<>();
+ try {
+ action.run();
+ for (ILoggingEvent event : appender.list) {
+ captured.add(event.getFormattedMessage().toLowerCase());
+ }
+ } finally {
+ sqlLogger.detachAppender(appender);
+ sqlLogger.setLevel(previous);
+ }
+ return captured;
+ }
+
+ private com.fasterxml.jackson.databind.JsonNode json(String body) {
+ try {
+ return com.yunhai.formcenter.common.FormSchemaValidator.mapper().readTree(body);
+ } catch (Exception e) {
+ throw new IllegalStateException("测试 JSON 写错了：" + body, e);
+ }
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerSubmitIT.java b/src/test/java/com/yunhai/formcenter/service/AnswerSubmitIT.java
index 9119b04..28313bd 100644
--- a/src/test/java/com/yunhai/formcenter/service/AnswerSubmitIT.java
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerSubmitIT.java
@@ -6,9 +6,11 @@ import com.yunhai.formcenter.enums.FormEnums;
import com.yunhai.formcenter.model.AnswerModels;
import com.yunhai.formcenter.model.FormModels;
import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.model.BoaUser;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
@@ -28,6 +30,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
* 由 {@code AnswerConcurrencyIT} 用双线程打真库取证。
*/
@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
@Transactional
@DisplayName("AnswerService - 提交链路（V17/V31/V32/V33）")
class AnswerSubmitIT extends AnswerTestSupport {
@@ -84,7 +87,7 @@ class AnswerSubmitIT extends AnswerTestSupport {
@DisplayName("V17 正向：有管理权者可代填他人——submitter=操作人、subject=被代填人（两键各司其职，方案 §6.3）")
void adminCanFillOnBehalf() {
String code = "v17_proxy";
- publishForm(code, SCHEMA);
+ String formUuid = publishForm(code, SCHEMA);
Integer teacherId = 10001;
Integer studentId = 20269001;
@@ -95,6 +98,43 @@ class AnswerSubmitIT extends AnswerTestSupport {
Answer stored = answerRepository.findByUuidAndSchId(view.getAnswerId(), SCH).get();
assertThat(stored.getSubmitterId()).isEqualTo(teacherId);
assertThat(stored.getSubjectId()).isEqualTo(studentId);
+ // P25：钉版坐标的第二维=resolvePublished 命中的那张表单，提交时写死、之后不随升版改变
+ assertThat(stored.getFormUuid()).isEqualTo(formUuid);
+ }
+
+ @Test
+ @DisplayName("P33：代填的 subject 查无此人或跨校=PARAM_ERROR（存在性与同校一起判；本人自填不查）")
+ void proxySubjectMustExistInSessionSchool() {
+ String code = "p33_subject";
+ publishForm(code, SCHEMA);
+ BoaUser admin = user(10001, SCH, 7);
+
+ Integer missing = 20269999;
+ subjects.markMissing(missing);
+ AnswerModels.SubmitRequest toMissing = submit(code, VALUES);
+ toMissing.setSubjectId(missing);
+ assertThatThrownBy(() -> answerService.submit(admin, toMissing))
+ .isInstanceOf(BizException.class).hasMessageContaining("被代填人不存在或不属于本校");
+
+ Integer foreign = 20268888;
+ subjects.markSchool(foreign, OTHER_SCH);
+ AnswerModels.SubmitRequest toForeign = submit(code, VALUES);
+ toForeign.setSubjectId(foreign);
+ assertThatThrownBy(() -> answerService.submit(admin, toForeign))
+ .isInstanceOf(BizException.class).hasMessageContaining("被代填人不存在或不属于本校");
+
+ // 正向：同校真实存在的人可代填；=自己（普通用户）不触发 UserBase 查询
+ Integer ok = 20267777;
+ subjects.markSchool(ok, SCH);
+ AnswerModels.SubmitRequest good = submit(code, VALUES);
+ good.setSubjectId(ok);
+ assertThat(answerService.submit(admin, good).getAnswerId()).isNotBlank();
+
+ BoaUser student = user(20266666, SCH, 3);
+ AnswerModels.SubmitRequest self = submit(code, VALUES);
+ self.setSubjectId(20266666);
+ subjects.markMissing(20266666); // 即便登记为"查不到"，本人自填也不该去验存在性（会话里的人必然存在）
+ assertThat(answerService.submit(student, self).getAnswerId()).isNotBlank();
}
@Test
@@ -223,7 +263,7 @@ class AnswerSubmitIT extends AnswerTestSupport {
first.setSubjectId(student);
AnswerModels.SubmitView view = answerService.submit(user(10001, SCH, 7), first);
- adminService.softDelete(SCH, 10001, view.getAnswerId());
+ adminService.softDelete(manager(10001), SCH, view.getAnswerId());
AnswerModels.SubmitRequest refill = submit(code, "{\"name\":\"重新填的\",\"grade\":\"g3\"}");
refill.setSubjectId(student);
diff --git a/src/test/java/com/yunhai/formcenter/service/AnswerTestSupport.java b/src/test/java/com/yunhai/formcenter/service/AnswerTestSupport.java
index d52edb3..b3ec4e5 100644
--- a/src/test/java/com/yunhai/formcenter/service/AnswerTestSupport.java
+++ b/src/test/java/com/yunhai/formcenter/service/AnswerTestSupport.java
@@ -6,23 +6,35 @@ import com.yunhai.formcenter.model.FormModels;
import com.yunhai.formcenter.repository.AnswerRepository;
import com.yunhai.platform.utils.model.BoaRoleInfo;
import com.yunhai.platform.utils.model.BoaUser;
+import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.TestConfiguration;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Primary;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
- * 答卷域测试脚手架（T3 各 IT 共用）：会话用户构造 + 建表单并发布 + 提交入参拼装。
+ * 答卷/数据面集成测试脚手架（T3 起各 IT 共用，T4 扩读路径）：会话用户构造 + 建表单并发布 + 提交入参拼装
+ * + 两个外部事实源的测试桩。
*
* 身份载体是平台 POJO {@link BoaUser}（真实链路由 CAS 过滤器填充），
* 测试直接造它——这正是 V17 的断言方式：服务签名里只有 {@code BoaUser} 与请求体，
* 请求体没有 {@code schId/submitterId} 字段，身份只能来自会话对象。
+ *
+ * 两个外部事实源用桩顶掉（{@link TestGatewayConfiguration}，本地 IT 不启动 UserBase/CAS）：
+ * {@link ModuleTreeSource}（授权模块集=P21 的管理权口径 + customId 范围升级位）与
+ * {@link SubjectDirectory}（P33 的代填存在性）。生产实现是平台签名调用，接线在 T9 联调验；
+ * 本轮取证的是"规则本身对不对"，桩把事实源钉住即可。
*/
abstract class AnswerTestSupport {
/** 测试专用租户域（避开真实开发库数据；IT 结束一律回滚或显式清理） */
protected static final long SCH = 990301L;
protected static final long OTHER_SCH = 990302L;
+ /** 管理动作的操作人 id（断言留痕 operator_id 时用它，稳定复现） */
+ protected static final int MANAGER_ID = 10001;
private static final AtomicInteger USER_SEQ = new AtomicInteger(20000);
@@ -44,6 +56,18 @@ abstract class AnswerTestSupport {
@Autowired
protected AnswerIndexService indexService;
+ @Autowired
+ protected InMemoryModuleTreeSource moduleTree;
+
+ @Autowired
+ protected InMemorySubjectDirectory subjects;
+
+ @BeforeEach
+ void resetGateways() {
+ moduleTree.reset();
+ subjects.reset();
+ }
+
// ==================== 会话用户 ====================
/** 普通用户（学生 roleId=3 / 教师 roleId=1）：无管理权，subject 只能=自己 */
@@ -66,6 +90,23 @@ abstract class AnswerTestSupport {
return user(USER_SEQ.incrementAndGet(), OTHER_SCH, 7, 2);
}
+ /**
+ * 管理员操作人（roleId=7 + 被授权数据管理/定义管理模块行）。
+ *
+ * T4 起管理权看授权模块集（P21 口径），单有 roleId 不再等于能管理——所以"管理员"在测试里
+ * 就是这两件事一起造。需要"管理员但没被授权"的反例时用 {@link #user(Integer, Long, Integer)}
+ * 再 {@code moduleTree.clear(id)}。
+ */
+ protected BoaUser manager() {
+ return manager(MANAGER_ID);
+ }
+
+ protected BoaUser manager(Integer id) {
+ BoaUser user = user(id, SCH, 7, 2);
+ moduleTree.grantManageDefaults(id);
+ return user;
+ }
+
/** 指定 id 的会话用户（并发/限次用例需要"同一个人"稳定复现） */
protected BoaUser user(Integer id, Long schId, Integer roleId, Integer type) {
BoaUser user = new BoaUser();
@@ -76,6 +117,10 @@ abstract class AnswerTestSupport {
current.setRoleId(roleId);
current.setSchId(schId.intValue());
user.setCurrentRole(current);
+ if (roleId != null && roleId == 7) {
+ // 管理员在测试语义里=被授权中心模块行的人（手册 §2.2）；反例显式 clear
+ moduleTree.grantManageDefaults(id);
+ }
return user;
}
@@ -136,4 +181,28 @@ abstract class AnswerTestSupport {
throw new IllegalStateException("测试 JSON 写错了：" + json, e);
}
}
+
+ // ==================== 外部事实源桩 ====================
+
+ /**
+ * IT 上下文里的两个网关桩（{@code @Primary} 顶掉平台签名实现）。
+ *
+ * 声明在本脚手架的嵌套类里：所有答卷域 IT 都继承它，因此共享同一份上下文配置
+ * （Spring 的嵌套 {@code @TestConfiguration} 会沿测试类继承链发现）。
+ */
+ @TestConfiguration
+ static class TestGatewayConfiguration {
+
+ @Bean
+ @Primary
+ InMemoryModuleTreeSource inMemoryModuleTreeSource() {
+ return new InMemoryModuleTreeSource();
+ }
+
+ @Bean
+ @Primary
+ InMemorySubjectDirectory inMemorySubjectDirectory() {
+ return new InMemorySubjectDirectory();
+ }
+ }
}
diff --git a/src/test/java/com/yunhai/formcenter/service/DataScopeServiceTest.java b/src/test/java/com/yunhai/formcenter/service/DataScopeServiceTest.java
new file mode 100644
index 0000000..7810eac
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/DataScopeServiceTest.java
@@ -0,0 +1,232 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.Form;
+import com.yunhai.formcenter.enums.FormEnums;
+import com.yunhai.formcenter.enums.FormEnums.DataScope;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.model.BoaModule;
+import com.yunhai.platform.utils.model.BoaRoleInfo;
+import com.yunhai.platform.utils.model.BoaUser;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * 数据范围解析单测（自验项 V28 全部 + V42 的"身份默认矩阵/customId 升级/回落"三半边）。
+ *
+ * 矩阵（契约 §8）在这里逐格断言；"受限身份的统计/导出 ⊆ 列表可见集"那半边是接口级事实，
+ * 在 {@code AnswerReadIT} 打真库断言。桩只顶掉模块树来源（UserBase 事实源），
+ * 解析规则本身全部走生产代码。
+ */
+@DisplayName("DataScopeService - 契约 §8 矩阵与 customId 升级（V28/V42）")
+class DataScopeServiceTest {
+
+ private static final int STUDENT_FACING = FormEnums.Audience.STUDENT.getCode();
+ private static final int TEACHER_FACING = FormEnums.Audience.TEACHER.getCode();
+
+ private final InMemoryModuleTreeSource tree = new InMemoryModuleTreeSource();
+ private final DataScopeService service = new DataScopeService(tree, Arrays.asList(
+ new AllScopeImplementor(), new SelfSubmittedScopeImplementor(),
+ new AboutMeScopeImplementor(), new TeachingClassScopeImplementor()));
+
+ // ==================== V42：身份默认矩阵 ====================
+
+ @Test
+ @DisplayName("V42 矩阵：管理员(7)/校领导(2)=全部，两种面向人群都是全部")
+ void adminAndLeaderSeeAll() {
+ for (int roleId : Arrays.asList(7, 2)) {
+ assertThat(service.resolve(user(roleId), form(STUDENT_FACING))).containsExactly(DataScope.ALL);
+ assertThat(service.resolve(user(roleId), form(TEACHER_FACING))).containsExactly(DataScope.ALL);
+ }
+ }
+
+ @Test
+ @DisplayName("V42 矩阵：教师(1)×面向学生=一期生效仅本人提交（任教班级实现器缺席）；×面向教师=仅本人提交")
+ void teacherScopes() {
+ assertThat(service.resolve(user(1), form(STUDENT_FACING))).containsExactly(DataScope.SELF_SUBMITTED);
+ assertThat(service.resolve(user(1), form(TEACHER_FACING))).containsExactly(DataScope.SELF_SUBMITTED);
+ }
+
+ @Test
+ @DisplayName("V42 矩阵：学生(3)×面向学生=关于我（老师代填的那条也可见）；×面向教师按最保守兜底")
+ void studentScopes() {
+ assertThat(service.resolve(user(3), form(STUDENT_FACING))).containsExactly(DataScope.ABOUT_ME);
+ assertThat(service.resolve(user(3), form(TEACHER_FACING))).containsExactly(DataScope.SELF_SUBMITTED);
+ }
+
+ @Test
+ @DisplayName("V42 矩阵：家长(4)/工作号(6)/局领导(5)=回落仅本人提交（两种人群都是）")
+ void peripheralRolesFallBackToSelf() {
+ for (int roleId : Arrays.asList(4, 6, 5)) {
+ assertThat(service.resolve(user(roleId), form(STUDENT_FACING)))
+ .as("roleId=" + roleId + " 面向学生")
+ .containsExactly(DataScope.SELF_SUBMITTED);
+ assertThat(service.resolve(user(roleId), form(TEACHER_FACING)))
+ .as("roleId=" + roleId + " 面向教师")
+ .containsExactly(DataScope.SELF_SUBMITTED);
+ }
+ }
+
+ @Test
+ @DisplayName("V42 全不命中：没有任何 roleIds（异常身份）也落到仅本人提交，不是全部")
+ void noRolesAtAllFallsBackToSelf() {
+ BoaUser nobody = new BoaUser();
+ nobody.setId(20001);
+ nobody.setCurrentRole(role(9, 990301));
+ assertThat(service.resolve(nobody, form(STUDENT_FACING))).containsExactly(DataScope.SELF_SUBMITTED);
+ }
+
+ @Test
+ @DisplayName("V42 多来源取最宽=并集：同时有学生与教师身份时，关于我与仅本人提交两格都在（不是二选一）")
+ void multipleIdentitiesUnion() {
+ BoaUser user = new BoaUser();
+ user.setId(20002);
+ user.setType(0);
+ user.setRoleIds(Arrays.asList(1, 3));
+ user.setCurrentRole(role(1, 990301));
+ Set scopes = service.resolve(user, form(STUDENT_FACING));
+ assertThat(scopes).containsExactlyInAnyOrder(DataScope.SELF_SUBMITTED, DataScope.ABOUT_ME);
+
+ // 其中一格是"全部"时收敛为全部（其余都是它的子集，留着只让读路径多写 OR）
+ user.setRoleIds(Arrays.asList(1, 3, 7));
+ assertThat(service.resolve(user, form(STUDENT_FACING))).containsExactly(DataScope.ALL);
+ }
+
+ // ==================== V42：customId 升级位 ====================
+
+ @Test
+ @DisplayName("V42 扩展：授权 customId=fc:scope:all 的模块行后，该组成员范围升级为全部")
+ void customIdAnchorUpgradesToAll() {
+ BoaUser teacher = user(1);
+ assertThat(service.resolve(teacher, form(STUDENT_FACING))).containsExactly(DataScope.SELF_SUBMITTED);
+
+ tree.grantCustomId(teacher.getId(), DataScopeService.SCOPE_ALL_CUSTOM_ID);
+ assertThat(service.resolve(teacher, form(STUDENT_FACING))).containsExactly(DataScope.ALL);
+ }
+
+ @Test
+ @DisplayName("customId 扫描是递归的（UserBase 下发的是树，锚点在子层也算命中）且只认 customId 不认 path")
+ void anchorScanIsRecursiveAndExact() {
+ BoaUser teacher = user(1);
+
+ InMemoryModuleTreeSource nested = new InMemoryModuleTreeSource();
+ nested.grantNested(teacher.getId(), "/admin/data",
+ Collections.singletonList(InMemoryModuleTreeSource.child(null,
+ DataScopeService.SCOPE_ALL_CUSTOM_ID)));
+ assertThat(serviceWith(nested).resolve(teacher, form(STUDENT_FACING))).containsExactly(DataScope.ALL);
+
+ // 只授权了页面路由行（path）不升级范围——第②层管理权与第③层数据范围是两条正交的口径
+ InMemoryModuleTreeSource pathOnly = new InMemoryModuleTreeSource();
+ pathOnly.grantPaths(teacher.getId(), "/admin/data", "/admin/forms");
+ assertThat(serviceWith(pathOnly).resolve(teacher, form(STUDENT_FACING)))
+ .containsExactly(DataScope.SELF_SUBMITTED);
+ }
+
+ // ==================== V28：任教班级在枚举里但一期不可选 ====================
+
+ @Test
+ @DisplayName("V28：契约 §8 四值都在枚举里；一期可选集合只有三个（任教班级缺席）")
+ void teachingClassIsInEnumButNotSelectable() {
+ assertThat(DataScope.values()).containsExactly(
+ DataScope.ALL, DataScope.TEACHING_CLASS, DataScope.SELF_SUBMITTED, DataScope.ABOUT_ME);
+ assertThat(service.selectableScopes()).containsExactlyInAnyOrder(
+ DataScope.ALL, DataScope.SELF_SUBMITTED, DataScope.ABOUT_ME);
+ assertThat(service.selectableScopes()).doesNotContain(DataScope.TEACHING_CLASS);
+ }
+
+ @Test
+ @DisplayName("V28：任何身份×任何人群都解析不出任教班级（矩阵直接给生效值）")
+ void noCombinationResolvesToTeachingClass() {
+ for (int roleId : new int[]{1, 2, 3, 4, 5, 6, 7}) {
+ for (int audience : new int[]{STUDENT_FACING, TEACHER_FACING}) {
+ assertThat(service.resolve(user(roleId), form(audience)))
+ .as("roleId=" + roleId + " audience=" + audience)
+ .doesNotContain(DataScope.TEACHING_CLASS);
+ }
+ }
+ }
+
+ @Test
+ @DisplayName("V28：任教班级实现器被误用时明确报错（1.5 开放前不存在可用谓词），不会静默按全部放行")
+ void teachingClassImplementorRefusesToBuildPredicate() {
+ assertThatThrownBy(() -> service.implementorOf(DataScope.TEACHING_CLASS)
+ .rowPredicate(null, null, 1))
+ .isInstanceOf(BizException.class)
+ .hasMessageContaining("一期未开放");
+ }
+
+ // ==================== 其它 ====================
+
+ @Test
+ @DisplayName("超管（type==1）恒为全部：它不受单校开通约束（方案 §6.5），平台级行的读侧同口径")
+ void superAdminSeesAll() {
+ BoaUser root = new BoaUser();
+ root.setId(1);
+ root.setType(1);
+ assertThat(service.resolve(root, form(TEACHER_FACING))).containsExactly(DataScope.ALL);
+ }
+
+ @Test
+ @DisplayName("未登录不解析范围（拒绝，而不是给一个兜底范围）")
+ void requiresSession() {
+ assertThatThrownBy(() -> service.resolve(null, form(STUDENT_FACING)))
+ .isInstanceOf(BizException.class).hasMessageContaining("未登录");
+ assertThatThrownBy(() -> service.resolve(new BoaUser(), form(STUDENT_FACING)))
+ .hasMessageContaining("未登录");
+ }
+
+ @Test
+ @DisplayName("表单为 null（如平台级读上下文缺失）按面向学生列解析，不抛空指针")
+ void nullFormUsesStudentColumn() {
+ assertThat(service.resolve(user(3), null)).containsExactly(DataScope.ABOUT_ME);
+ assertThat(service.resolve(user(1), null)).containsExactly(DataScope.SELF_SUBMITTED);
+ }
+
+ @Test
+ @DisplayName("实现器注册表按枚举取用；未注册的范围视为配置缺失直接报错（不静默当全部）")
+ void unknownScopeFailsLoud() {
+ DataScopeService partial = new DataScopeService(tree,
+ new ArrayList<>(Arrays.asList(new AllScopeImplementor())));
+ assertThatThrownBy(() -> partial.implementorOf(DataScope.ABOUT_ME))
+ .isInstanceOf(BizException.class).hasMessageContaining("缺少实现器");
+ }
+
+ // ==================== 构造小工具 ====================
+
+ private BoaUser user(int roleId) {
+ BoaUser user = new BoaUser();
+ user.setId(20000 + roleId);
+ user.setType(0);
+ user.setRoleIds(Collections.singletonList(roleId));
+ user.setCurrentRole(role(roleId, 990301));
+ return user;
+ }
+
+ private BoaRoleInfo role(Integer roleId, int schId) {
+ BoaRoleInfo info = new BoaRoleInfo();
+ info.setRoleId(roleId);
+ info.setSchId(schId);
+ return info;
+ }
+
+ private Form form(int audience) {
+ Form form = new Form();
+ form.setAudience(audience);
+ return form;
+ }
+
+ /** 换一个模块树桩组同一个解析器（实现器集合与生产装配一致：四值四个实现器） */
+ private DataScopeService serviceWith(InMemoryModuleTreeSource source) {
+ return new DataScopeService(source, Arrays.asList(
+ new AllScopeImplementor(), new SelfSubmittedScopeImplementor(),
+ new AboutMeScopeImplementor(), new TeachingClassScopeImplementor()));
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/FormAdminGuardTest.java b/src/test/java/com/yunhai/formcenter/service/FormAdminGuardTest.java
index fe09da7..7ee1234 100644
--- a/src/test/java/com/yunhai/formcenter/service/FormAdminGuardTest.java
+++ b/src/test/java/com/yunhai/formcenter/service/FormAdminGuardTest.java
@@ -1,84 +1,149 @@
package com.yunhai.formcenter.service;
import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.model.BoaModule;
import com.yunhai.platform.utils.model.BoaRoleInfo;
import com.yunhai.platform.utils.model.BoaUser;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatCode;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
/**
- * 管理权闸门单测（执行手册 §5 P21 裁决的落地断言，也是 V17/V14/V29 的权限层依据）。
+ * 管理权闸门单测（执行手册 §5 P21 裁决的 T4 到期替换：授权模块集口径，roleId 硬编码整体移除）。
*
- * 口径：超管 {@code type==1}（UserBase {@code UserTypeEnum.SUPER_ADMIN}）可跨校且唯一可管
- * {@code sch_id=0} 平台级行；校级限 {@code roleId ∈ {2 校领导, 7 管理员}}——
- * 局领导(5) 被明确移出（契约 §8 矩阵里 5=回落"仅本人提交"，属查看角色非维护角色）。
- * 这是 T4 换成"授权模块集"口径之前的过渡态。
+ * 口径：能进哪个管理面=被授权哪个模块行（手册 §2.2 表：定义管理 {@code /admin/forms}、
+ * 数据管理 {@code /admin/data}、统计 {@code /admin/stats}、字典管理 {@code /admin/dicts}）；
+ * 超管（{@code type==1}，UserBase 用户类型不是 roleId）仍可跨校且唯一可管 {@code sch_id=0} 平台级行
+ * （方案 §6.5"超管不受单校开通约束"）。
+ *
+ * 桩={@link ModuleTreeSource} 的 lambda——本类不启 Spring、不连库，验证的是"给定授权集合，
+ * 判定对不对"。真实树来自 UserBase 的链路在 T9 联调验。
*/
-@DisplayName("FormAdminGuard - P21 过渡闸门")
+@DisplayName("FormAdminGuard - 授权模块集口径（P21 替换后）")
class FormAdminGuardTest {
private static final long SCH = 880001L;
- private final FormAdminGuard guard = new FormAdminGuard();
+ @Test
+ @DisplayName("被授权数据管理模块行=可进数据面；同 roleId 但未授权=拒（管理权不再来自角色）")
+ void moduleGrantIsTheGate() {
+ FormAdminGuard guard = guardWith("/admin/data");
+ assertThat(guard.requireAdmin(schoolUser(7), null, FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
+ // 教师被授权了数据管理行同样能进（第②层与第③层正交：能进接口≠能看全部行，行级范围另判）
+ assertThat(guard.requireAdmin(schoolUser(1), null, FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
+
+ FormAdminGuard none = guardWith();
+ for (int roleId : Arrays.asList(1, 2, 3, 5, 6, 7)) {
+ assertThatThrownBy(() -> none.requireAdmin(schoolUser(roleId), null,
+ FormAdminGuard.MODULE_DATA_MANAGE))
+ .as("roleId=" + roleId + " 未授权模块行")
+ .isInstanceOf(BizException.class)
+ .hasMessageContaining("无该模块权限");
+ }
+ }
@Test
- @DisplayName("P21 收紧：校领导(2)/管理员(7) 可管且只能管本校；局领导(5) 与教师(1)/学生(3) 都不可管")
- void onlyRoleIdsTwoAndSevenManage() {
- assertThat(guard.requireAdmin(schoolUser(2), null)).isEqualTo(SCH);
- assertThat(guard.requireAdmin(schoolUser(7), null)).isEqualTo(SCH);
+ @DisplayName("四个模块行互不通用：只有定义管理权的人调字典面被拒（口径=手册 §2.2 一行一权）")
+ void modulesAreNotInterchangeable() {
+ FormAdminGuard guard = guardWith(FormAdminGuard.MODULE_FORM_DESIGN);
+ assertThatCode(() -> guard.requireAdmin(schoolUser(2), null, FormAdminGuard.MODULE_FORM_DESIGN))
+ .doesNotThrowAnyException();
+ assertThatThrownBy(() -> guard.requireAdmin(schoolUser(2), null, FormAdminGuard.MODULE_DICT))
+ .hasMessageContaining(FormAdminGuard.MODULE_DICT);
+ assertThatThrownBy(() -> guard.requireAdmin(schoolUser(2), null, FormAdminGuard.MODULE_STATS))
+ .hasMessageContaining(FormAdminGuard.MODULE_STATS);
+ }
- for (int roleId : Arrays.asList(5, 1, 3, 4, 6)) {
- assertThatThrownBy(() -> guard.requireAdmin(schoolUser(roleId), null))
- .as("roleId=" + roleId)
- .isInstanceOf(BizException.class)
- .hasMessageContaining("无表单管理权限");
- assertThat(guard.canManage(schoolUser(roleId))).as("canManage roleId=" + roleId).isFalse();
- }
+ @Test
+ @DisplayName("统计的\"二选一\"配法：授权 /admin/stats 或 /admin/data 任一即可（手册 §2.2 统计可并入数据管理）")
+ void statsAcceptsEitherModuleRow() {
+ assertThat(guardWith(FormAdminGuard.MODULE_STATS)
+ .requireAdminAny(schoolUser(7), null, FormAdminGuard.MODULE_STATS,
+ FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
+ assertThat(guardWith(FormAdminGuard.MODULE_DATA_MANAGE)
+ .requireAdminAny(schoolUser(7), null, FormAdminGuard.MODULE_STATS,
+ FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
+ assertThatThrownBy(() -> guardWith(FormAdminGuard.MODULE_DICT)
+ .requireAdminAny(schoolUser(7), null, FormAdminGuard.MODULE_STATS,
+ FormAdminGuard.MODULE_DATA_MANAGE))
+ .isInstanceOf(BizException.class).hasMessageContaining("需任一");
+ }
+
+ @Test
+ @DisplayName("path 空的权限锚点（customId=fc:scope:all）不给管理权——它是数据范围升级位，不是模块行")
+ void scopeAnchorIsNotAModuleRow() {
+ FormAdminGuard guard = new FormAdminGuard(user -> {
+ BoaModule anchor = new BoaModule();
+ anchor.setCustomId(DataScopeService.SCOPE_ALL_CUSTOM_ID);
+ anchor.setChildren(new ArrayList());
+ List rows = new ArrayList<>();
+ rows.add(anchor);
+ return rows;
+ });
+ assertThatThrownBy(() -> guard.requireAdmin(schoolUser(7), null, FormAdminGuard.MODULE_DATA_MANAGE))
+ .hasMessageContaining("无该模块权限");
+ assertThat(guard.canManage(schoolUser(7))).isFalse();
+ }
+
+ @Test
+ @DisplayName("canManage（代填分支）：数据管理或定义管理任一即有管理权；只有字典管理没有；未授权没有")
+ void canManageFollowsModuleSet() {
+ assertThat(guardWith(FormAdminGuard.MODULE_DATA_MANAGE).canManage(schoolUser(1))).isTrue();
+ assertThat(guardWith(FormAdminGuard.MODULE_FORM_DESIGN).canManage(schoolUser(1))).isTrue();
+ assertThat(guardWith(FormAdminGuard.MODULE_DICT).canManage(schoolUser(7))).isFalse();
+ assertThat(guardWith().canManage(schoolUser(7))).isFalse();
}
@Test
@DisplayName("校级管理员指定他校 schId 被拒（含把 schId 传成 0 想碰平台级行）")
void schoolAdminCannotCrossDomain() {
+ FormAdminGuard guard = guardWith(FormAdminGuard.MODULE_DATA_MANAGE);
BoaUser admin = schoolUser(7);
- assertThatThrownBy(() -> guard.requireAdmin(admin, 999999L))
+ assertThatThrownBy(() -> guard.requireAdmin(admin, 999999L, FormAdminGuard.MODULE_DATA_MANAGE))
.isInstanceOf(BizException.class).hasMessageContaining("仅可管理本校");
- assertThatThrownBy(() -> guard.requireAdmin(admin, 0L))
+ assertThatThrownBy(() -> guard.requireAdmin(admin, 0L, FormAdminGuard.MODULE_DATA_MANAGE))
.hasMessageContaining("仅超管可维护");
}
@Test
- @DisplayName("超管可显式指定任意域（含 0=平台级），未指定时回落当前身份学校")
- void superAdminCanTargetAnyDomain() {
+ @DisplayName("超管可显式指定任意域（含 0=平台级），未被授权模块行也能进；无当前身份时必须显式给域")
+ void superAdminBypassesModuleRows() {
+ FormAdminGuard guard = guardWith();
BoaUser root = new BoaUser();
root.setId(1);
root.setType(1);
- assertThat(guard.requireAdmin(root, 0L)).isEqualTo(0L);
- assertThat(guard.requireAdmin(root, SCH)).isEqualTo(SCH);
+ assertThat(guard.requireAdmin(root, 0L, FormAdminGuard.MODULE_DICT)).isEqualTo(0L);
+ assertThat(guard.requireAdmin(root, SCH, FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
root.setCurrentRole(role(3, (int) SCH));
- assertThat(guard.requireAdmin(root, null)).isEqualTo(SCH);
+ assertThat(guard.requireAdmin(root, null, FormAdminGuard.MODULE_DATA_MANAGE)).isEqualTo(SCH);
assertThat(guard.canManage(root)).isTrue();
BoaUser rootWithoutSchool = new BoaUser();
rootWithoutSchool.setId(1);
rootWithoutSchool.setType(1);
- assertThatThrownBy(() -> guard.requireAdmin(rootWithoutSchool, null))
- .hasMessageContaining("超管请显式指定 schId");
+ assertThatThrownBy(() -> guard.requireAdmin(rootWithoutSchool, null,
+ FormAdminGuard.MODULE_DATA_MANAGE)).hasMessageContaining("超管请显式指定 schId");
}
@Test
@DisplayName("无会话=UNAUTHORIZED（不是 FORBIDDEN）——契约 §6 定稿映射的未登录段")
void missingSessionIsUnauthorized() {
- assertThatThrownBy(() -> guard.requireAdmin(null, null))
+ FormAdminGuard guard = guardWith(FormAdminGuard.MODULE_DATA_MANAGE);
+ assertThatThrownBy(() -> guard.requireAdmin(null, null, FormAdminGuard.MODULE_DATA_MANAGE))
.isInstanceOf(BizException.class).hasMessageContaining("未登录");
BoaUser anonymous = new BoaUser();
- assertThatThrownBy(() -> guard.requireAdmin(anonymous, null)).hasMessageContaining("未登录");
+ assertThatThrownBy(() -> guard.requireAdmin(anonymous, null, FormAdminGuard.MODULE_DATA_MANAGE))
+ .hasMessageContaining("未登录");
+ assertThatThrownBy(() -> guard.requireAdminAny(anonymous, null, FormAdminGuard.MODULE_STATS))
+ .hasMessageContaining("未登录");
assertThat(guard.canManage(null)).isFalse();
assertThat(guard.canManage(anonymous)).isFalse();
}
@@ -86,15 +151,32 @@ class FormAdminGuardTest {
@Test
@DisplayName("有当前身份但无学校归属（区域组/根直属）不算管理权——不给出「本校」域")
void noSchoolBindingIsNotAdmin() {
+ FormAdminGuard guard = guardWith(FormAdminGuard.MODULE_DATA_MANAGE);
BoaUser user = new BoaUser();
user.setId(10133);
user.setRoleIds(Collections.singletonList(7));
user.setCurrentRole(role(7, null));
- assertThatThrownBy(() -> guard.requireAdmin(user, null)).hasMessageContaining("无表单管理权限");
+ assertThatThrownBy(() -> guard.requireAdmin(user, null, FormAdminGuard.MODULE_DATA_MANAGE))
+ .hasMessageContaining("无学校归属");
assertThat(guard.canManage(user)).isFalse();
BoaUser full = schoolUser(7);
- assertThatCode(() -> guard.requireAdmin(full, SCH)).doesNotThrowAnyException();
+ assertThatCode(() -> guard.requireAdmin(full, SCH, FormAdminGuard.MODULE_DATA_MANAGE))
+ .doesNotThrowAnyException();
+ }
+
+ /** 授权集合直给的守卫（模块行 path 变参；path 空行不在此列，见锚点用例） */
+ private static FormAdminGuard guardWith(String... paths) {
+ return new FormAdminGuard(user -> {
+ List rows = new ArrayList<>();
+ for (String path : paths) {
+ BoaModule module = new BoaModule();
+ module.setPath(path);
+ module.setChildren(new ArrayList());
+ rows.add(module);
+ }
+ return rows;
+ });
}
private BoaUser schoolUser(int roleId) {
diff --git a/src/test/java/com/yunhai/formcenter/service/FormFileServiceIT.java b/src/test/java/com/yunhai/formcenter/service/FormFileServiceIT.java
index 436059c..2fe9e6d 100644
--- a/src/test/java/com/yunhai/formcenter/service/FormFileServiceIT.java
+++ b/src/test/java/com/yunhai/formcenter/service/FormFileServiceIT.java
@@ -9,6 +9,7 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
import org.springframework.mock.web.MockMultipartFile;
import org.springframework.test.context.TestPropertySource;
import org.springframework.transaction.annotation.Transactional;
@@ -34,6 +35,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
* 即"未注入平台 env 时读 jar 内本地键"这条真实分支——测试顺手把这条读取形态钉住了。
*/
@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
@Transactional
@TestPropertySource(properties = "file.upload-path=target/tmp-upload")
@DisplayName("FormFileService - 上传模块（V24 本地部分）")
@@ -179,6 +181,18 @@ class FormFileServiceIT extends AnswerTestSupport {
"{\"name\":\"张三\",\"cert\":[{\"id\":" + realId + ",\"fileName\":\"cert.jpg\","
+ "\"key\":\"http://cdn.example/cert.jpg\"}]}")))
.hasMessageContaining("相对存储路径");
+
+ // P34：id 是真的、key 却指向别的相对路径——挂得住 id 也挂不住语义，仍拒（跨租户渲染的前置条件之一）
+ assertThatThrownBy(() -> answerService.submit(user(10001, SCH, 3), submit(code,
+ "{\"name\":\"张三\",\"cert\":[{\"id\":" + realId + ",\"fileName\":\"cert.jpg\","
+ + "\"key\":\"form/2026/10/someone-else.jpg\"}]}")))
+ .isInstanceOf(BizException.class).hasMessageContaining("附件 key 与上传记录不一致");
+
+ // P34：fileName 顺带比对（合法前端原样转存返回值，这里不改坏正常流程）
+ assertThatThrownBy(() -> answerService.submit(user(10001, SCH, 3), submit(code,
+ "{\"name\":\"张三\",\"cert\":[{\"id\":" + realId + ",\"fileName\":\"改名.jpg\","
+ + "\"key\":\"" + uploaded.getKey() + "\"}]}")))
+ .isInstanceOf(BizException.class).hasMessageContaining("附件文件名与上传记录不一致");
}
// ==================== 小工具 ====================
diff --git a/src/test/java/com/yunhai/formcenter/service/InMemoryModuleTreeSource.java b/src/test/java/com/yunhai/formcenter/service/InMemoryModuleTreeSource.java
new file mode 100644
index 0000000..c20dae2
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/InMemoryModuleTreeSource.java
@@ -0,0 +1,95 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.platform.utils.model.BoaModule;
+import com.yunhai.platform.utils.model.BoaUser;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * {@link ModuleTreeSource} 的测试桩（T4：本地 IT 不启动 UserBase/CAS，P21 的授权模块集口径
+ * 与契约 §8 的 customId 扫描都注入这里取证，真实链路 T9 联调验）。
+ *
+ * 建模的是 UserBase 侧的两种模块行（手册 §2.2）：{@code path} 非空=页面路由行、
+ * {@code path} 空 + {@code customId}=纯权限锚点。缺省不给任何模块——与生产侧
+ * fail-closed 同向（无授权=无管理权、范围回落仅本人提交），需要权限的用例显式授权。
+ */
+public class InMemoryModuleTreeSource implements ModuleTreeSource {
+
+ private final Map> byUser = new ConcurrentHashMap<>();
+
+ /** 授权页面路由模块行（path 逐字用手册 §2.2 的那几条） */
+ public void grantPaths(Integer userId, String... paths) {
+ List rows = rows(userId);
+ for (String path : paths) {
+ rows.add(row(path, null));
+ }
+ }
+
+ /** 授权 path 空的权限锚点（数据范围升级位 {@code fc:scope:all} 就是这种形态） */
+ public void grantCustomId(Integer userId, String customId) {
+ rows(userId).add(row(null, customId));
+ }
+
+ /** 清空某人的授权（构造"角色是管理员但没被授权模块行"的反例） */
+ public void clear(Integer userId) {
+ byUser.remove(userId);
+ }
+
+ /** 每条用例前清空全部授权（脚手架 @BeforeEach 调它，防用例间串权限） */
+ public void reset() {
+ byUser.clear();
+ }
+
+ public List pathsOf(Integer userId) {
+ List paths = new ArrayList<>();
+ for (BoaModule module : byUser.getOrDefault(userId, Collections.emptyList())) {
+ if (module.getPath() != null) {
+ paths.add(module.getPath());
+ }
+ }
+ return paths;
+ }
+
+ @Override
+ public List authorizedModules(BoaUser user) {
+ if (user == null || user.getId() == null) {
+ return Collections.emptyList();
+ }
+ // 桩返回扁平列表即可：FormModuleKeys 的递归遍历对 children=null 与树形都同样处理
+ return Collections.unmodifiableList(
+ new ArrayList<>(byUser.getOrDefault(user.getId(), Collections.emptyList())));
+ }
+
+ private List rows(Integer userId) {
+ return byUser.computeIfAbsent(userId, key -> Collections.synchronizedList(new ArrayList<>()));
+ }
+
+ private static BoaModule row(String path, String customId) {
+ BoaModule module = new BoaModule();
+ module.setPath(path);
+ module.setCustomId(customId);
+ module.setName(path == null ? "权限锚点 " + customId : "模块 " + path);
+ module.setChildren(new ArrayList());
+ return module;
+ }
+
+ /** 便于用例一行授权"数据管理 + 定义管理"（=手册 §2.2 的中心管理员常见配法） */
+ public void grantManageDefaults(Integer userId) {
+ grantPaths(userId, FormAdminGuard.MODULE_DATA_MANAGE, FormAdminGuard.MODULE_FORM_DESIGN);
+ }
+
+ /** 树形下发形态（有子节点）：验证扫描是递归的，不只读顶层 */
+ public void grantNested(Integer userId, String parentPath, List children) {
+ BoaModule parent = row(parentPath, null);
+ parent.setChildren(new ArrayList<>(children));
+ rows(userId).add(parent);
+ }
+
+ public static BoaModule child(String path, String customId) {
+ return row(path, customId);
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/InMemorySubjectDirectory.java b/src/test/java/com/yunhai/formcenter/service/InMemorySubjectDirectory.java
new file mode 100644
index 0000000..6843773
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/InMemorySubjectDirectory.java
@@ -0,0 +1,47 @@
+package com.yunhai.formcenter.service;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * {@link SubjectDirectory} 的测试桩（P33：本地 IT 不启动 UserBase，代填存在性/同校判定注入这里取证）。
+ *
+ * 缺省口径=「UserBase 正常返回该用户且与查询者同校」，因为绝大多数用例关心的是别的规则；
+ * 需要反例时用 {@link #markMissing} / {@link #markSchool} 显式登记，
+ * 这样 P33 的两条拒绝分支（查不到、跨校）都有独立断言。
+ */
+public class InMemorySubjectDirectory implements SubjectDirectory {
+
+ private final Set missing = Collections.newSetFromMap(new ConcurrentHashMap());
+ private final Map schoolOf = new ConcurrentHashMap<>();
+
+ /** 登记"查无此人" */
+ public void markMissing(Integer subjectId) {
+ missing.add(subjectId);
+ }
+
+ /** 登记该 id 的真实归属校（跨校反例用） */
+ public void markSchool(Integer subjectId, Long schId) {
+ schoolOf.put(subjectId, schId);
+ missing.remove(subjectId);
+ }
+
+ public void reset() {
+ missing.clear();
+ schoolOf.clear();
+ }
+
+ @Override
+ public boolean existsInSchool(Integer subjectId, Long schId) {
+ if (subjectId == null || schId == null) {
+ return false;
+ }
+ if (missing.contains(subjectId)) {
+ return false;
+ }
+ Long owner = schoolOf.get(subjectId);
+ return owner == null || owner.equals(schId);
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/OapiFormServiceIT.java b/src/test/java/com/yunhai/formcenter/service/OapiFormServiceIT.java
new file mode 100644
index 0000000..63ca943
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/OapiFormServiceIT.java
@@ -0,0 +1,183 @@
+package com.yunhai.formcenter.service;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.yunhai.formcenter.model.FormModels;
+import com.yunhai.formcenter.model.OapiModels;
+import com.yunhai.platform.apistd.BizException;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Import;
+import org.springframework.transaction.annotation.Transactional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/**
+ * 对外读接口集成测试（契约 §9 两端点 + §4 下发形状；真实 MySQL）。
+ *
+ * 断言的四件事：
+ *
+ * - 自包含：字典引用在出参里已内联展开成 {@code options:[{label,value}]}，
+ * 消费方不需要再请求字典（契约 §2.1）；
+ * - 机读值形状：每个字段带 {@code valueSchema}（{@code FormValueSchemaBuilderTest} 已逐类断言形状，
+ * 这里断言它真的出现在下发链路里）；
+ * - 遮蔽规则与填报入口同源：{@code /oapi/form/schema} 走的就是 {@code resolvePublished}，
+ * 本校表单建好后同一请求指向本校行（契约 §1）；
+ * - 答卷给的是钉住版本：升版后读历史答卷，schema 仍是它提交时那张表（契约 §9"快照"语义的前提）。
+ *
+ *
+ * 信封 {@code code=0} 与验签墙是平台链（{@code /oapi/*} 401 由 {@code local-debug/t4-read-smoke.sh}
+ * 启动冒烟取证），本类断言的是 data 载荷内容。
+ */
+@SpringBootTest
+@Import(AnswerTestSupport.TestGatewayConfiguration.class)
+@Transactional
+@DisplayName("对外读接口 - /oapi/form/schema 与 /answer（契约 §4/§9）")
+class OapiFormServiceIT extends AnswerTestSupport {
+
+ private static final String CODE = "t4_oapi_honor";
+
+ /** grade 走字典引用（内联展开的取证点），score/cert 走 valueSchema 的 number/附件类 */
+ private static final String SCHEMA = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"grade\",\"label\":\"年级\",\"type\":\"select\",\"required\":true,\"searchable\":true,"
+ + "\"options\":{\"source\":\"dict:grades\"}},"
+ + "{\"key\":\"score\",\"label\":\"分数\",\"type\":\"number\"},"
+ + "{\"key\":\"cert\",\"label\":\"证书\",\"type\":\"image\",\"maxFiles\":3}"
+ + "]}]}";
+
+ /** v2：多一个"新字段"，用于证明历史答卷给的仍是 v1 的表 */
+ private static final String SCHEMA_V2 = SCHEMA.replace(
+ "{\"key\":\"cert\"", "{\"key\":\"extra\",\"label\":\"新字段\",\"type\":\"text\"},{\"key\":\"cert\"");
+
+ @Autowired
+ private OapiFormService oapiFormService;
+
+ @Test
+ @DisplayName("schema 下发：字典已内联成 options、每字段带 valueSchema、audience 给枚举名、无库内 id")
+ void schemaIsSelfContainedWithInlineOptions() {
+ String formUuid = publishForm(CODE, SCHEMA);
+
+ OapiModels.SchemaView view = oapiFormService.schema(SCH, null, CODE);
+ assertThat(view.getFormUuid()).isEqualTo(formUuid);
+ assertThat(view.getVersion()).isEqualTo(1);
+ assertThat(view.getCode()).isEqualTo(CODE);
+ assertThat(view.getAppCode()).isEqualTo("form-center");
+ assertThat(view.getAudience()).isEqualTo("STUDENT");
+
+ JsonNode grade = field(view.getGroups(), "grade");
+ assertThat(grade.path("options").isArray()).isTrue();
+ assertThat(grade.path("options")).extracting(node -> node.path("value").asText())
+ .containsExactly("g2", "g3");
+ assertThat(grade.path("options").get(0).path("label").asText()).isEqualTo("高二年级");
+ assertThat(grade.path("valueSchema").path("enum")).extracting(JsonNode::asText)
+ .containsExactly("g2", "g3");
+ assertThat(field(view.getGroups(), "score").path("valueSchema").path("type").asText())
+ .isEqualTo("number");
+ assertThat(field(view.getGroups(), "cert").path("valueSchema").path("items")
+ .path("additionalProperties").asBoolean()).isFalse();
+ // 字典本身不出现在出参里（引用键已被替换）
+ assertThat(view.getGroups().toString()).doesNotContain("dict:grades");
+ }
+
+ @Test
+ @DisplayName("schema 的 resolve 语义：本校同 code 表单遮蔽平台级；他校专属 code 在别校查不到")
+ void schemaFollowsShadowingAndDomainRules() {
+ String platformUuid = publishForm(0L, CODE, SCHEMA); // 平台级表单
+ // 域=会话校 ∪ 平台级：别校也能解析到平台级行（契约 §1，这不是越权——平台级本就共享）
+ assertThat(oapiFormService.schema(SCH, null, CODE).getFormUuid()).isEqualTo(platformUuid);
+ assertThat(oapiFormService.schema(OTHER_SCH, null, CODE).getFormUuid()).isEqualTo(platformUuid);
+
+ String schoolUuid = publishForm(SCH, CODE, SCHEMA); // 本校同 code 表单：遮蔽生效
+ assertThat(oapiFormService.schema(SCH, null, CODE).getFormUuid()).isEqualTo(schoolUuid);
+ // 遮蔽不穿透：他校请求同 (app_code, code) 仍只命中平台级那一行，不会被指到本校表单
+ assertThat(oapiFormService.schema(OTHER_SCH, null, CODE).getFormUuid()).isEqualTo(platformUuid);
+
+ // 纯校级表单（无平台级同 code 行）在别校域里查不到
+ String schoolOnlyCode = "t4_oapi_school_only";
+ publishForm(SCH, schoolOnlyCode, SCHEMA);
+ assertThatThrownBy(() -> oapiFormService.schema(OTHER_SCH, null, schoolOnlyCode))
+ .isInstanceOf(BizException.class).hasMessageContaining("表单不存在");
+
+ assertThatThrownBy(() -> oapiFormService.schema(null, null, CODE))
+ .isInstanceOf(BizException.class).hasMessageContaining("schId");
+ assertThatThrownBy(() -> oapiFormService.schema(SCH, "other-app", CODE))
+ .isInstanceOf(BizException.class).hasMessageContaining("表单不存在");
+ }
+
+ @Test
+ @DisplayName("answer 下发：给的是钉住版本的 schema + 值文档；升版后历史答卷的形状不漂移（契约 §9 快照语义）")
+ void answerCarriesItsPinnedVersionSchema() {
+ String formUuid = publishForm(CODE, SCHEMA);
+ String answerId = answerService.submit(plainUser(3),
+ submit(CODE, "{\"grade\":\"g2\",\"score\":95.5}")).getAnswerId();
+
+ // 升版（新字段 extra）
+ FormModels.FormSaveRequest save = new FormModels.FormSaveRequest();
+ save.setUuid(formUuid);
+ save.setSchemaJson(SCHEMA_V2);
+ defService.save(SCH, save);
+ defService.publish(SCH, formUuid, "加新字段");
+
+ OapiModels.AnswerView view = oapiFormService.answer(SCH, answerId);
+ assertThat(view.getAnswerId()).isEqualTo(answerId);
+ assertThat(view.getVersion()).isEqualTo(1);
+ assertThat(view.getFormUuid()).isEqualTo(formUuid);
+ assertThat(view.getSchemaRef().getVersion()).isEqualTo(1);
+ assertThat(view.getValues().path("score").asDouble()).isEqualTo(95.5);
+ assertThat(view.getStatus()).isEqualTo("pending");
+ assertThat(view.getSubmitTime()).isNotBlank();
+ assertThat(view.getGroups().toString()).doesNotContain("新字段"); // 给的是 v1 那张表
+ assertThat(field(view.getGroups(), "grade").path("options").isArray()).isTrue();
+
+ // 软删与跨校都读不到（与四条 CAS 读路径同口径）
+ adminService.softDelete(manager(), SCH, answerId);
+ assertThatThrownBy(() -> oapiFormService.answer(SCH, answerId))
+ .isInstanceOf(BizException.class).hasMessageContaining("答卷不存在");
+ }
+
+ @Test
+ @DisplayName("answer 的租户域由调用方声明：别的 schId 读不到本校答卷（不给跨校探测面）")
+ void answerIsDomainBound() {
+ publishForm(CODE, SCHEMA);
+ String answerId = answerService.submit(plainUser(3), submit(CODE, "{\"grade\":\"g2\"}")).getAnswerId();
+ assertThatThrownBy(() -> oapiFormService.answer(OTHER_SCH, answerId))
+ .isInstanceOf(BizException.class).hasMessageContaining("答卷不存在");
+ assertThatThrownBy(() -> oapiFormService.answer(SCH, null))
+ .isInstanceOf(BizException.class).hasMessageContaining("answerId 不能为空");
+ }
+
+ // ==================== 小工具 ====================
+
+ /** 建字典（grades：高二年级=g2 / 高三年级=g3）+ 表单 + 发布，返回表单 uuid */
+ @Override
+ protected String publishForm(String code, String schemaJson) {
+ return publishForm(SCH, code, schemaJson);
+ }
+
+ /** 平台级表单（sch_id=0）也要能在本类的字典引用下发布，故两个重载都先备字典 */
+ @Override
+ protected String publishForm(Long schId, String code, String schemaJson) {
+ ensureDict(schId);
+ return super.publishForm(schId, code, schemaJson);
+ }
+
+ /** 本级字典（服务层方法不带守卫，测试直接建 0 级/校级的行） */
+ private void ensureDict(Long schId) {
+ dictService.saveDict(schId, "grades", "年级");
+ dictService.saveItem(schId, "grades", "g2", "高二年级", 0);
+ dictService.saveItem(schId, "grades", "g3", "高三年级", 1);
+ }
+
+ private static JsonNode field(JsonNode groups, String key) {
+ for (JsonNode group : groups) {
+ for (JsonNode field : group.path("fields")) {
+ if (key.equals(field.path("key").asText())) {
+ return field;
+ }
+ }
+ }
+ throw new IllegalStateException("下发 schema 里没有字段 " + key);
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/PlatformSubjectDirectoryTest.java b/src/test/java/com/yunhai/formcenter/service/PlatformSubjectDirectoryTest.java
new file mode 100644
index 0000000..5a7bd7a
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/PlatformSubjectDirectoryTest.java
@@ -0,0 +1,73 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.platform.utils.model.BoaGroup;
+import com.yunhai.platform.utils.model.BoaRoleInfo;
+import com.yunhai.platform.utils.model.BoaUser;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * 代填对象的学校归属判定单测（P33 的判定半边——存在性那半边在 IT 里用桩顶掉 UserBase 调用）。
+ *
+ * 判据取 UserBase {@code /oapi/user/byId} 下发的三层字段：{@code schools}（全部可选身份的学校，
+ * 本期起填充）为主，{@code school}（当前激活学校）与 {@code currentRole.schId} 为兜底——
+ * 三层任一含会话校即算同校。之所以不只看 {@code school}：多校身份的人当前激活校是"切到哪所"的运行时状态，
+ * 用它判同校会把合法的第二身份代填误拒。
+ */
+@DisplayName("PlatformSubjectDirectory - 同校归属判定（P33）")
+class PlatformSubjectDirectoryTest {
+
+ @Test
+ @DisplayName("schools 含目标校=同校；不含则再看 school/currentRole")
+ void checksAllThreeAffiliationFields() {
+ assertThat(PlatformSubjectDirectory.belongsToSchool(withSchools(7L, 990301L), 990301L)).isTrue();
+ assertThat(PlatformSubjectDirectory.belongsToSchool(withSchools(7L, 123L), 990301L)).isFalse();
+
+ BoaUser currentSchoolOnly = new BoaUser();
+ currentSchoolOnly.setSchool(group(990301));
+ assertThat(PlatformSubjectDirectory.belongsToSchool(currentSchoolOnly, 990301L)).isTrue();
+ assertThat(PlatformSubjectDirectory.belongsToSchool(currentSchoolOnly, 990302L)).isFalse();
+
+ BoaUser roleOnly = new BoaUser();
+ BoaRoleInfo role = new BoaRoleInfo();
+ role.setSchId(990301);
+ roleOnly.setCurrentRole(role);
+ assertThat(PlatformSubjectDirectory.belongsToSchool(roleOnly, 990301L)).isTrue();
+ }
+
+ @Test
+ @DisplayName("空对象/空域一律按\"不属于本校\"处理（fail-closed：查不到就拒，不给代填开门）")
+ void nullsAreNotSameSchool() {
+ assertThat(PlatformSubjectDirectory.belongsToSchool(null, 990301L)).isFalse();
+ assertThat(PlatformSubjectDirectory.belongsToSchool(new BoaUser(), 990301L)).isFalse();
+ assertThat(PlatformSubjectDirectory.belongsToSchool(withSchools(1L), null)).isFalse();
+ BoaUser emptyLists = new BoaUser();
+ emptyLists.setSchools(Collections.emptyList());
+ assertThat(PlatformSubjectDirectory.belongsToSchool(emptyLists, 990301L)).isFalse();
+ }
+
+ private BoaUser withSchools(long... schoolIds) {
+ BoaUser user = new BoaUser();
+ user.setSchools(Arrays.asList(groups(schoolIds)));
+ return user;
+ }
+
+ private BoaGroup[] groups(long... schoolIds) {
+ BoaGroup[] array = new BoaGroup[schoolIds.length];
+ for (int i = 0; i < schoolIds.length; i++) {
+ array[i] = group((int) schoolIds[i]);
+ }
+ return array;
+ }
+
+ private BoaGroup group(Integer id) {
+ BoaGroup group = new BoaGroup();
+ group.setId(id);
+ return group;
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/ReadFixture.java b/src/test/java/com/yunhai/formcenter/service/ReadFixture.java
new file mode 100644
index 0000000..debfff3
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/ReadFixture.java
@@ -0,0 +1,160 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.model.AnswerModels;
+import com.yunhai.formcenter.model.FormModels;
+import com.yunhai.platform.utils.model.BoaUser;
+
+/**
+ * 读路径 IT 的数据集脚手架（T4）：两个表单（面向学生/面向教师）× 多身份 × 软删混合的答卷，
+ * 供 {@code AnswerReadIT}（列表/详情/统计/范围）与 {@code AnswerExportIT}（V37）共用同一份事实，
+ * 从而能逐身份比对"统计/导出 ⊆ 列表可见集"（V27/V42 的硬断言）。
+ *
+ * 数据集刻意包含的形状：
+ *
+ * - {@code advisor} 字段在 v1 schema 里存在但不声明 searchable，v2 才声明——
+ * V9（升版声明 searchable 后旧答卷可按新字段筛，靠发布时补建索引行）用的就是它；
+ * - {@code cert} 是 upload 且被勾了 searchable——P28（无检索算子：不写索引行、不进筛选候选）；
+ * - 学生自填的行 {@code subject_id} 为空、管理员代填的行 {@code subject_id}=学生——
+ * 契约 §8"学生=关于我"与"仅本人提交"两格的差异只有这种数据才测得出来；
+ * - 一条被软删的行——四条读出路径都必须看不见（V30 的读侧半边）。
+ *
+ */
+class ReadFixture {
+
+ /** 表单 A：面向学生（矩阵走"面向学生"那一列） */
+ static final String FORM_A = "t4_read_a";
+ /** 表单 B：面向教师（矩阵走"面向教师"那一列） */
+ static final String FORM_B = "t4_read_b";
+
+ static final String SCHEMA_V1 = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"name\",\"label\":\"姓名\",\"type\":\"text\",\"required\":true,\"searchable\":true},"
+ + "{\"key\":\"grade\",\"label\":\"年级\",\"type\":\"select\",\"required\":true,\"searchable\":true,"
+ + "\"options\":[{\"label\":\"高二\",\"value\":\"g2\"},{\"label\":\"高三\",\"value\":\"g3\"}]},"
+ + "{\"key\":\"score\",\"label\":\"分数\",\"type\":\"number\",\"searchable\":true},"
+ + "{\"key\":\"birthday\",\"label\":\"出生日期\",\"type\":\"date\",\"searchable\":true},"
+ + "{\"key\":\"advisor\",\"label\":\"指导教师\",\"type\":\"text\"},"
+ + "{\"key\":\"cert\",\"label\":\"证书照片\",\"type\":\"upload\",\"searchable\":true,"
+ + "\"accept\":\".jpg,.png\",\"maxFiles\":9}"
+ + "]}]}";
+
+ /** 升版：advisor 声明 searchable（V9 的用例面），其余逐字不变 */
+ static final String SCHEMA_V2 = SCHEMA_V1.replace(
+ "{\"key\":\"advisor\",\"label\":\"指导教师\",\"type\":\"text\"}",
+ "{\"key\":\"advisor\",\"label\":\"指导教师\",\"type\":\"text\",\"searchable\":true}");
+
+ static final String SCHEMA_TEACHER = "{\"groups\":[{\"key\":\"base\",\"label\":\"基本信息\",\"fields\":["
+ + "{\"key\":\"name\",\"label\":\"姓名\",\"type\":\"text\",\"required\":true,\"searchable\":true},"
+ + "{\"key\":\"grade\",\"label\":\"年级\",\"type\":\"select\",\"searchable\":true,"
+ + "\"options\":[{\"label\":\"高二\",\"value\":\"g2\"},{\"label\":\"高三\",\"value\":\"g3\"}]}"
+ + "]}]}";
+
+ /** 稳定 id：代填与范围断言要反复引用同一个人 */
+ static final int STUDENT_1 = 20264001;
+ static final int STUDENT_2 = 20264002;
+ static final int TEACHER_1 = 20264101;
+ static final int TEACHER_2 = 20264102;
+ static final int BUREAU_LEADER = 20264201;
+
+ private final AnswerTestSupport support;
+
+ ReadFixture(AnswerTestSupport support) {
+ this.support = support;
+ }
+
+ /** 答卷 uuid 集（按写入顺序命名，断言直接引用） */
+ static final class Rows {
+ /** 学生1 自填：grade g2 / score 90 / advisor 李老师 */
+ String student1Self;
+ /** 学生2 自填：grade g3 / score 80 / advisor 王老师 */
+ String student2Self;
+ /** 管理员代填学生1：grade g2 / score 70 / advisor 李老师（subject=学生1、submitter=管理员） */
+ String proxyForStudent1;
+ /** 教师1 自填：grade g3 / score 95 / advisor 张老师 */
+ String teacher1Self;
+ /** 教师2 自填：grade g2 / score 60 / advisor 张老师 */
+ String teacher2Self;
+ /** 学生2 自填后被软删（四条读路径都看不见） */
+ String softDeleted;
+ /** 表单 B（面向教师）上教师1 自填的一条 */
+ String teacherFacingRow;
+ /** 表单 A 的 uuid（列表/统计/导出的入参，读路径按表单 uuid 寻址） */
+ String formAUuid;
+ /** 表单 B 的 uuid */
+ String formBUuid;
+ }
+
+ /**
+ * 建 A/B 两表单（B 配成面向教师）并造出上述答卷，返回 uuid 集。
+ *
+ * @param admin 有数据管理权且有学校归属的操作人（代填与软删用它）
+ */
+ Rows seed(BoaUser admin) {
+ Rows rows = new Rows();
+ rows.formAUuid = support.publishForm(FORM_A, SCHEMA_V1);
+ rows.formBUuid = support.publishForm(FORM_B, SCHEMA_TEACHER);
+ FormModels.FormConfigRequest config = new FormModels.FormConfigRequest();
+ config.setAudience(2);
+ support.config(AnswerTestSupport.SCH, rows.formBUuid, config);
+
+ rows.student1Self = submit(student1(), FORM_A,
+ "{\"name\":\"张三\",\"grade\":\"g2\",\"score\":90,\"birthday\":\"2010-03-09\","
+ + "\"advisor\":\"李老师\"}");
+ rows.student2Self = submit(student2(), FORM_A,
+ "{\"name\":\"李四\",\"grade\":\"g3\",\"score\":80,\"birthday\":\"2009-11-02\","
+ + "\"advisor\":\"王老师\"}");
+ rows.proxyForStudent1 = submitProxy(admin, FORM_A, STUDENT_1,
+ "{\"name\":\"张三（老师代填）\",\"grade\":\"g2\",\"score\":70,\"birthday\":\"2010-03-09\","
+ + "\"advisor\":\"李老师\"}");
+ rows.teacher1Self = submit(teacher1(), FORM_A,
+ "{\"name\":\"王五\",\"grade\":\"g3\",\"score\":95,\"birthday\":\"2009-05-20\","
+ + "\"advisor\":\"张老师\"}");
+ rows.teacher2Self = submit(teacher2(), FORM_A,
+ "{\"name\":\"赵六\",\"grade\":\"g2\",\"score\":60,\"birthday\":\"2010-01-15\","
+ + "\"advisor\":\"张老师\"}");
+ rows.softDeleted = submit(student2(), FORM_A,
+ "{\"name\":\"被删的行\",\"grade\":\"g3\",\"score\":10,\"birthday\":\"2009-01-01\","
+ + "\"advisor\":\"李老师\"}");
+ support.adminService.softDelete(admin, AnswerTestSupport.SCH, rows.softDeleted);
+ rows.teacherFacingRow = submit(teacher1(), FORM_B, "{\"name\":\"教师问卷\",\"grade\":\"g2\"}");
+ return rows;
+ }
+
+ /** 升版 v2（advisor 声明 searchable）——发布动作内含索引补建（V9） */
+ void upgradeToV2(String formUuid) {
+ FormModels.FormSaveRequest save = new FormModels.FormSaveRequest();
+ save.setUuid(formUuid);
+ save.setSchemaJson(SCHEMA_V2);
+ support.defService.save(AnswerTestSupport.SCH, save);
+ support.defService.publish(AnswerTestSupport.SCH, formUuid, "指导教师改为可筛");
+ }
+
+ String submit(BoaUser user, String code, String valuesJson) {
+ return support.answerService.submit(user, support.submit(code, valuesJson)).getAnswerId();
+ }
+
+ String submitProxy(BoaUser admin, String code, int subjectId, String valuesJson) {
+ AnswerModels.SubmitRequest req = support.submit(code, valuesJson);
+ req.setSubjectId(subjectId);
+ return support.answerService.submit(admin, req).getAnswerId();
+ }
+
+ BoaUser student1() {
+ return support.user(STUDENT_1, AnswerTestSupport.SCH, 3);
+ }
+
+ BoaUser student2() {
+ return support.user(STUDENT_2, AnswerTestSupport.SCH, 3);
+ }
+
+ BoaUser teacher1() {
+ return support.user(TEACHER_1, AnswerTestSupport.SCH, 1);
+ }
+
+ BoaUser teacher2() {
+ return support.user(TEACHER_2, AnswerTestSupport.SCH, 1);
+ }
+
+ BoaUser bureauLeader() {
+ return support.user(BUREAU_LEADER, AnswerTestSupport.SCH, 5);
+ }
+}
diff --git a/src/test/java/com/yunhai/formcenter/service/XlsxReader.java b/src/test/java/com/yunhai/formcenter/service/XlsxReader.java
new file mode 100644
index 0000000..a65ee42
--- /dev/null
+++ b/src/test/java/com/yunhai/formcenter/service/XlsxReader.java
@@ -0,0 +1,60 @@
+package com.yunhai.formcenter.service;
+
+import com.alibaba.excel.EasyExcel;
+
+import java.io.ByteArrayInputStream;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 测试侧读回导出 xlsx 的工具（V37 的取证要按"文件里到底写了什么"断言，不能只看服务返回值）。
+ *
+ * 用 easyexcel 自己的同步读：无模型类时返回 {@code List>}；
+ * {@code headRowNumber(0)} 表示表头也当数据行读回来（列顺序与表头文案的断言用）。
+ */
+final class XlsxReader {
+
+ private XlsxReader() {
+ }
+
+ /** 全部行（第 0 行是表头） */
+ @SuppressWarnings("unchecked")
+ static List> allRows(byte[] xlsx) {
+ List raw = EasyExcel.read(new ByteArrayInputStream(xlsx)).sheet(0).headRowNumber(0).doReadSync();
+ List> rows = new ArrayList<>();
+ for (Object row : raw) {
+ rows.add((Map) row);
+ }
+ return rows;
+ }
+
+ /** 数据行（去掉表头行） */
+ static List> dataRows(byte[] xlsx) {
+ List> all = allRows(xlsx);
+ return all.isEmpty() ? all : new ArrayList<>(all.subList(1, all.size()));
+ }
+
+ /** 第一列（答卷ID uuid）集合——"导出 ⊆ 列表可见集"的断言载体 */
+ static List firstColumn(byte[] xlsx) {
+ List values = new ArrayList<>();
+ for (Map row : dataRows(xlsx)) {
+ values.add(row.get(0));
+ }
+ return values;
+ }
+
+ /** 表头文案（按列序） */
+ static List headers(byte[] xlsx) {
+ List> all = allRows(xlsx);
+ List titles = new ArrayList<>();
+ if (all.isEmpty()) {
+ return titles;
+ }
+ Map header = all.get(0);
+ for (int column = 0; column < header.size(); column++) {
+ titles.add(header.get(column));
+ }
+ return titles;
+ }
+}