schIds);
}
diff --git a/src/main/java/com/yunhai/formcenter/service/AnswerService.java b/src/main/java/com/yunhai/formcenter/service/AnswerService.java
index 92cbbb9..0b3d0e0 100644
--- a/src/main/java/com/yunhai/formcenter/service/AnswerService.java
+++ b/src/main/java/com/yunhai/formcenter/service/AnswerService.java
@@ -25,19 +25,25 @@ import org.springframework.transaction.support.TransactionTemplate;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
+import java.util.Set;
import java.util.UUID;
/**
* 提交链路（契约 §5 / 方案 §5.4）。一次提交在这条流水线上依次过关：
*
*
- * 钉版解析 → 截止 → 幂等命中 → subject 授权+存在性同校(P33) → 值校验(按钉住版本)
- * → 附件归属与 key 一致(P34) → 限次占位(fill_quota 撞键即拒) → 落 answer(写 form_uuid)
- * → 写 answer_index(只写 searchable)
+ * 钉版解析 → 第 0 关·填报入口层(P95) → 截止 → 幂等命中 → subject 授权+存在性同校(P33)
+ * → 值校验(按钉住版本) → 附件归属与 key 一致(P34) → 限次占位(fill_quota 撞键即拒)
+ * → 落 answer(写 form_uuid) → 写 answer_index(只写 searchable)
*
*
* 为什么顺序是这样：
*
+ * - 先鉴权后业务（P95）：入口层放在钉版之后（要 {@code form.audience} 才能判人群）、
+ * 截止之前（过期表单对无资格的人不该输出"已过期"这种业务信息）。
+ * 幂等重落在闸门之后，所以被闸门拒的人重放同样是 403——这是任务书 W2 明示可接受的取舍；
+ * 外层 {@code DataIntegrityViolationException} 的并发重放路径不再重复过闸（命中
+ * {@code belongsToCaller} 即返回原答卷）；
* - 幂等检查必须在限次之前——重放的那一条本来就占着名额，先查限次会把双击重试误判成"超过次数"；
* - 限次用"事务内向 {@code fill_quota} 插入、撞唯一键即拒"而不是先 count 再插
* （方案 §5.4 v1.4：两个并发提交不可能都通过 count 检查）；
@@ -46,6 +52,12 @@ import java.util.UUID;
* "软删条目仍放行"的口径也就无法表达（契约 §2.1）。
*
*
+ * 第 0 关与后面两关的分工：{@link FillAccessService} 判"这个身份在这张表单上算哪一层"
+ * （入口层，P95 起取代 {@code /f/{code}} 模块行授权）；{@link #requireSubject} 判"subject 能不能指向
+ * 别人"（ADMIN 沿 {@link FormAdminGuard#canManage} 现路径、MANAGE 走 P33 存在性）；
+ * {@link DataScopeService} 判"写进去之后谁能看见这行"（读矩阵，与本类无关）。
+ * 三条线各自独立，改一条不动另一条。
+ *
* 事务形态：公开方法不带 {@code @Transactional}，写库段用 {@link TransactionTemplate} 包。
* 目的是让"幂等键撞 uk"这种并发结局能在事务外重新读取原答卷并按契约返回 200+原 answer_id
* （撞键后当前事务已被标记回滚，事务内再读是不可靠的）。
@@ -62,6 +74,7 @@ public class AnswerService {
private final FormDefService defService;
private final FormDictService dictService;
private final FormAdminGuard adminGuard;
+ private final FillAccessService fillAccess;
private final SubjectDirectory subjectDirectory;
private final AnswerRepository answerRepository;
private final FillQuotaRepository quotaRepository;
@@ -99,12 +112,16 @@ public class AnswerService {
Form form = published.form();
String schemaJson = published.versionRow().getSchemaJson();
- // 2) 截止（datetime 粒度，过期接口拒绝，契约 §5）
+ // 2) 第 0 关（P95 三层模型）：填报入口层——钉版之后才有 audience 可判，截止之前先鉴权
+ Set tiers = fillAccess.resolve(user, form);
+ requireFillEntry(user, tiers, form, req.getSubjectId(), submitterId);
+
+ // 3) 截止（datetime 粒度，过期接口拒绝，契约 §5）
if (FormRuntimeRules.isDeadlineReached(form, LocalDateTime.now())) {
throw new BizException(ErrorCode.CUSTOM, "已过收集截止时间，不再接收提交：" + form.getCode());
}
- // 3) 幂等命中→200+原 answer_id（在限次之前，见类注释）
+ // 4) 幂等命中→200+原 answer_id（在限次之前，见类注释）
Answer existing = answerRepository.findByIdempotencyKey(idempotencyKey).orElse(null);
if (existing != null) {
if (!belongsToCaller(existing, user)) {
@@ -114,18 +131,18 @@ public class AnswerService {
return toView(existing, true);
}
- // 4) subject 授权（方案 §6.3：普通用户只能=自己，有管理权者可代填他人）+ 存在性/同校（P33）
- Integer subjectId = requireSubject(user, req.getSubjectId(), submitterId, schId);
+ // 5) subject 授权（P95 行为表：谁能代填由第 0 关的层决定）+ 存在性/同校（P33）
+ Integer subjectId = requireSubject(user, tiers, req.getSubjectId(), submitterId, schId);
- // 5) 值校验（按钉住版本；字典取值域含软删条目）+ 附件归属
+ // 6) 值校验（按钉住版本；字典取值域含软删条目）+ 附件归属
String valuesJson = valuesToJson(req.getValues());
FormValueValidator.validate(valuesJson, schemaJson, dictCode -> dictService.allowedValues(schId, dictCode));
assertAttachmentsOwned(schId, valuesJson, schemaJson);
- // 6) 限次占位（uk 是并发兜底）
+ // 7) 限次占位（uk 是并发兜底）
String quotaKey = occupyQuota(form, subjectId, submitterId);
- // 7) 落答卷
+ // 8) 落答卷
Answer answer = new Answer();
answer.setUuid(newUuid());
// P25：钉版溯源的精确坐标=resolvePublished 命中的那张表单（本校遮蔽平台时的胜出行）
@@ -147,7 +164,7 @@ public class AnswerService {
// 若这一步失败，同事务内的 fill_quota 占位一起回滚，不残留"名额被占但无答卷"的脏状态
answer = answerRepository.saveAndFlush(answer);
- // 8) 索引：只写 searchable 字段（V3/V9）
+ // 9) 索引：只写 searchable 字段（V3/V9）
indexService.write(answer, schemaJson);
log.info("[提交] answer={} form={}/{} v{} submitter={} subject={} quotaKey={}",
@@ -158,16 +175,45 @@ public class AnswerService {
// ==================== 各环节 ====================
- private Integer requireSubject(BoaUser user, Integer subjectId, Integer submitterId, Long schId) {
+ /**
+ * 第 0 关（P95 W2 行为表）：入口层判"这个身份在这张表单上到底能不能写"。
+ *
+ * 两条拒绝各有独立文案，因为它们是两种不同的用户动作失败了：
+ * NONE=压根不在面向人群里（家长/工作号/局领导、学生填教师问卷），直链进来也是 403；
+ * 仅 MANAGE 的自填=人在人群口径里、但档位只给代填不给自填（教师×学生面向），
+ * 文案要告诉他"改成代填学生就能提交"，否则这条 403 无从下手。
+ */
+ private void requireFillEntry(BoaUser user, Set tiers, Form form,
+ Integer subjectId, Integer submitterId) {
+ if (tiers.isEmpty()) {
+ throw new BizException(ErrorCode.FORBIDDEN, "无权填报该表单：表单「" + form.getCode() + "」面向"
+ + audienceLabel(form) + "，当前身份 " + sessionIdentity(user) + " 不在可填报人群内"
+ + "（可填=面向人群本人；教师可代填本校学生；管理员不受限）");
+ }
+ boolean proxy = subjectId != null && !subjectId.equals(submitterId);
+ if (!proxy && !fillAccess.canFill(tiers)) {
+ throw new BizException(ErrorCode.FORBIDDEN, "教师不能以本人身份填报学生面向表单，可代填本校学生"
+ + "（subjectId 传被代填学生 id）：表单「" + form.getCode() + "」面向" + audienceLabel(form));
+ }
+ }
+
+ private Integer requireSubject(BoaUser user, Set tiers, Integer subjectId,
+ Integer submitterId, Long schId) {
if (subjectId == null || subjectId.equals(submitterId)) {
return subjectId;
}
- if (!adminGuard.canManage(user)) {
- throw new BizException(ErrorCode.FORBIDDEN,
- "无权为他人填报：subjectId 只能等于本人（当前 " + submitterId + "，请求 " + subjectId + "）");
+ if (fillAccess.isAdmin(tiers)) {
+ // 层③的代填仍走 canManage 现路径（P95 红线 3"canManage 代填路径原样"）：
+ // 入口层把 ADMIN 判出来不等于给一条比现状更宽的写通道——没被授权管理模块行的人照旧拒
+ if (!adminGuard.canManage(user)) {
+ throw new BizException(ErrorCode.FORBIDDEN, forbiddenProxy(submitterId, subjectId));
+ }
+ } else if (!fillAccess.canProxy(tiers)) {
+ // 层①普通成员（学生×学生面向、教师×教师面向）代填=拒，与 P95 之前的现行为逐字同文案
+ throw new BizException(ErrorCode.FORBIDDEN, forbiddenProxy(submitterId, subjectId));
}
// P33：代填=把数据挂到别人名下，"关于我的"视图（V18）与按 subject 限次都建立在"id 真实且同校"上。
- // 本人自填不查（会话里的人本来就存在），只验代填那一个 id。
+ // 本人自填不查（会话里的人本来就存在），只验代填那一个 id。层②与层③共用这一条（红线 3）。
if (!subjectDirectory.existsInSchool(subjectId, schId)) {
throw new BizException(ErrorCode.PARAM_ERROR,
"被代填人不存在或不属于本校：subjectId=" + subjectId + "，schId=" + schId);
@@ -175,6 +221,24 @@ public class AnswerService {
return subjectId;
}
+ private static String forbiddenProxy(Integer submitterId, Integer subjectId) {
+ return "无权为他人填报：subjectId 只能等于本人（当前 " + submitterId + "，请求 " + subjectId + "）";
+ }
+
+ private static String audienceLabel(Form form) {
+ return FormEnums.Audience.TEACHER.getCode() == (form.getAudience() == null
+ ? FormEnums.Audience.STUDENT.getCode() : form.getAudience()) ? "教师" : "学生";
+ }
+
+ /** 拒绝文案里的身份要素（会话 roleIds + 当前身份，便于运维一眼看出是人群配错还是身份不对） */
+ private static String sessionIdentity(BoaUser user) {
+ StringBuilder sb = new StringBuilder("id=").append(user.getId()).append(" roleIds=").append(user.getRoleIds());
+ if (user.getCurrentRole() != null && user.getCurrentRole().getRoleId() != null) {
+ sb.append("（当前=").append(user.getCurrentRole().getRoleId()).append("）");
+ }
+ return sb.toString();
+ }
+
/** 返回占住的 limit_key（null=该表单不限次，未占位） */
private String occupyQuota(Form form, Integer subjectId, Integer submitterId) {
if (!FormEnums.FillLimit.once(form.getFillLimit())) {
diff --git a/src/main/java/com/yunhai/formcenter/service/FillAccessService.java b/src/main/java/com/yunhai/formcenter/service/FillAccessService.java
new file mode 100644
index 0000000..f536a1e
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/FillAccessService.java
@@ -0,0 +1,173 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.Form;
+import com.yunhai.formcenter.enums.FormEnums;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.exception.ErrorCode;
+import com.yunhai.platform.utils.model.BoaUser;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 填报入口层解析（P95 任务书 §0.1 三层角色模型）：把"会话用户 + 这张表单"解析成一个层集合，
+ * 回答"填报入口给不给这个人开、开到哪一档"。纯解析、无写路径、不碰任何一张表。
+ *
+ * 三条线的分工（互不越界，P95 红线 1/2）：
+ *
+ * - UserBase 模块行管"能不能进页面"——{@code /admin/*} 四行是管理面入口凭证
+ * （{@link FormAdminGuard}，P80 口径"入口只认模块行，两表只升范围"一字不动）。
+ * {@code /f/{code}} 填报模块行自 P95 起不再承担填报授权；
+ * - 本类管"填报入口给谁开"（P95 新增）——人群由表单的 {@code audience} × 会话身份 ×
+ * 管理员两表在中心侧自解析，不需要超管逐个表单配模块行；
+ * - {@link DataScopeService} 管"进页面后能看哪些行"（读矩阵，一字不动）。
+ *
+ * 三者判定因子有重叠（都看 roleIds、都看两表），但结论互不供给：本类不给数据面放行，
+ * 数据面也不给填报入口放行。
+ *
+ * 层与谓词（任务书 §0.1 表原样）：
+ *
+ * ADMIN 超管(type==1) ∪ school_admin 命中会话校 ∪ form_admin 命中该表单 ∪ roleIds 含 2/7
+ * MANAGE audience=学生 且 roleIds 含 1（教师）——可代填本校学生，数据面仍是"仅本人提交"
+ * FILL (audience=学生 且 roleIds 含 3) ∪ (audience=教师 且 roleIds 含 1)
+ * NONE 其余一切（家长4/局领导5/工作号6/未知角色、学生×教师面向、roleIds 全不命中）= 空集
+ *
+ *
+ * 多身份=并集：{@code roleIds}（全部正常态角色）∪ 会话 {@code currentRole.roleId}
+ * 逐层判定后合并（沿 {@link DataScopeService} 的 {@code identityRoleIds} 口径，防 UserBase 两侧不一致漏格）。
+ * 一个层集合可以同时含多层（如教师×学生面向 = {@code {MANAGE}}，校领导 = {@code {ADMIN}}）。
+ *
+ * 与任教班级 stub 的关系：层②的数据面语义就是现状（矩阵该格生效=仅本人提交），
+ * 本类只是把"教师可以往本校学生名下写数据"这件事从模块行授权收回到中心解析，
+ * {@code DataScopeService} 的注释与取值一概不动。
+ */
+@Service
+@RequiredArgsConstructor
+public class FillAccessService {
+
+ /** 超管用户类型（同 {@link FormAdminGuard}/{@link DataScopeService}：不是 roleId，是 UserBase 的用户类型） */
+ private static final int SUPER_ADMIN_TYPE = 1;
+
+ private static final int ROLE_TEACHER = 1;
+ private static final int ROLE_SCHOOL_LEADER = 2;
+ private static final int ROLE_STUDENT = 3;
+ private static final int ROLE_ADMIN = 7;
+
+ private final AdminScopeSource adminScopeSource;
+
+ /** 填报入口层（{@link #resolve} 的元素；未命中任何层=空集，语义即任务书里的 NONE） */
+ public enum Tier {
+ /** 层③：全部管理 + 可填 + 可代填 */
+ ADMIN,
+ /** 层②：教师×学生面向，可代填本校学生（数据面维持仅本人提交） */
+ MANAGE,
+ /** 层①：本人身份可填 */
+ FILL
+ }
+
+ /**
+ * 解析该会话用户在这张表单上的层集合。
+ *
+ * @param form 目标表单（{@code audience} 决定用哪一列，{@code uuid} 决定 form_admin 命中）；
+ * null 按面向学生列解析，且不产生 form_admin 命中（无表单可判），
+ * 与 {@link DataScopeService#resolve} 的 null 口径同形
+ * @return 层集合；空集=NONE（没有任何入口）。永不为 null
+ */
+ public Set resolve(BoaUser user, Form form) {
+ if (user == null || user.getId() == null) {
+ throw new BizException(ErrorCode.UNAUTHORIZED, "未登录");
+ }
+ Set tiers = EnumSet.noneOf(Tier.class);
+ List roleIds = identityRoleIds(user);
+ if (isSuperAdmin(user) || grantedByAdminTables(user, form) || holdsAdminRole(roleIds)) {
+ tiers.add(Tier.ADMIN);
+ }
+ boolean studentFacing = FormEnums.Audience.STUDENT.getCode()
+ == (form == null || form.getAudience() == null
+ ? FormEnums.Audience.STUDENT.getCode() : form.getAudience());
+ if (studentFacing && roleIds.contains(ROLE_TEACHER)) {
+ tiers.add(Tier.MANAGE);
+ }
+ if (studentFacing ? roleIds.contains(ROLE_STUDENT) : roleIds.contains(ROLE_TEACHER)) {
+ tiers.add(Tier.FILL);
+ }
+ return tiers;
+ }
+
+ /** 层①∪层③：能否以本人身份填报（层②只有代填，自填不在这里——由调用侧按行为表拒绝并给文案） */
+ public boolean canFill(Set tiers) {
+ return tiers != null && (tiers.contains(Tier.FILL) || tiers.contains(Tier.ADMIN));
+ }
+
+ /** 层②∪层③：能否代填他人（真正能不能落到某个人身上还要过 P33 的 existsInSchool） */
+ public boolean canProxy(Set tiers) {
+ return tiers != null && (tiers.contains(Tier.MANAGE) || tiers.contains(Tier.ADMIN));
+ }
+
+ /** 层③：管理员层命中（超管 / 两表 / 校领导(2) / 管理员(7)） */
+ public boolean isAdmin(Set tiers) {
+ return tiers != null && tiers.contains(Tier.ADMIN);
+ }
+
+ /** 并集里的最高层（序 ADMIN > MANAGE > FILL；空集返回 null=NONE），供列表的 {@code myTier} 用 */
+ public Tier topTier(Set tiers) {
+ if (tiers == null || tiers.isEmpty()) {
+ return null;
+ }
+ for (Tier candidate : Tier.values()) {
+ if (tiers.contains(candidate)) {
+ return candidate;
+ }
+ }
+ return null;
+ }
+
+ /**
+ * 管理员两表是否把这个人抬进层③：{@code school_admin} 命中会话校、
+ * 或 {@code form_admin} 命中这张表单（口径与 {@link DataScopeService} 读侧同源，
+ * 但结论只用在入口层，不改数据范围）。
+ *
+ * 与读侧的差别只有一处，且是有意的：两表在这里不看表单归属域。
+ * 读侧要区分"本校表单→全部 / 基础表单→本校提交"，而入口层问的是"这个人是不是管理员"，
+ * 基础表单的管理员同样是管理员；校域不变式（{@code answer.sch_id}=会话校）也不因代填而变。
+ */
+ private boolean grantedByAdminTables(BoaUser user, Form form) {
+ Long ownSch = sessionSchId(user);
+ if (ownSch != null && adminScopeSource.isSchoolAdmin(ownSch, user.getId())) {
+ return true;
+ }
+ return form != null && adminScopeSource.isFormAdmin(form.getUuid(), user.getId());
+ }
+
+ /** 校领导(2)/管理员(7)：平台标准角色里的管理身份（契约 §8 矩阵那两行同一个因子） */
+ private static boolean holdsAdminRole(List roleIds) {
+ return roleIds.contains(ROLE_ADMIN) || roleIds.contains(ROLE_SCHOOL_LEADER);
+ }
+
+ /** 参与解析的身份：{@code roleIds}（全部正常态角色）并上会话 {@code currentRole.roleId}（同 DataScopeService） */
+ private static List identityRoleIds(BoaUser user) {
+ List ids = new ArrayList<>();
+ if (user.getRoleIds() != null) {
+ ids.addAll(user.getRoleIds());
+ }
+ Integer current = user.getCurrentRole() == null ? null : user.getCurrentRole().getRoleId();
+ if (current != null && !ids.contains(current)) {
+ ids.add(current);
+ }
+ return ids.isEmpty() ? Collections.emptyList() : ids;
+ }
+
+ private static boolean isSuperAdmin(BoaUser user) {
+ return user.getType() != null && user.getType() == SUPER_ADMIN_TYPE;
+ }
+
+ private static Long sessionSchId(BoaUser user) {
+ Integer schId = user.getCurrentRole() == null ? null : user.getCurrentRole().getSchId();
+ return schId == null ? null : Long.valueOf(schId);
+ }
+}
diff --git a/src/main/java/com/yunhai/formcenter/service/FillableFormService.java b/src/main/java/com/yunhai/formcenter/service/FillableFormService.java
new file mode 100644
index 0000000..680c15f
--- /dev/null
+++ b/src/main/java/com/yunhai/formcenter/service/FillableFormService.java
@@ -0,0 +1,135 @@
+package com.yunhai.formcenter.service;
+
+import com.yunhai.formcenter.entity.Form;
+import com.yunhai.formcenter.model.MyModels;
+import com.yunhai.formcenter.repository.FormRepository;
+import com.yunhai.platform.apistd.BizException;
+import com.yunhai.platform.utils.exception.ErrorCode;
+import com.yunhai.platform.utils.model.BoaUser;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 「我可填」清单解析（P95 W3，{@code GET /api/form/my/fillable}）：把"这个会话用户能进哪些表单的填报页"
+ * 算成一张列表——P91 那个列表的数据源，从此不再吃 UserBase 模块树。
+ *
+ * 四步，一步不多：
+ *
+ * - 取域：会话校 ∪ 平台级（{@code sch_id=0}），只认 {@code status=1} 已发布且未软删的头表；
+ * - 遮蔽去重：同 {@code (app_code, code)} 本校与平台级都在时本校胜出且不回落——
+ * 直接复用 {@link FormDefService#pickByShadowing}，与 resolve 同一条 U5 实现（P20 的取舍：
+ * 两处口径必须同源，否则列表里出现的表单点进去可能解析成另一张）；
+ * - 逐行过入口层：{@link FillAccessService#resolve} 为空集（NONE）的行不入集；非空即入集，
+ * {@code canFill} 与 {@code myTier} 一起下发——层②（教师×面向学生）的行 {@code canFill=false}，
+ * 前端「可填写」列表把它筛掉，但"数据管理"tab 的候选要靠它，所以不能只下发一个布尔；
+ * - 排序：deadline 升序、null（不限）在后、同档按 code。
+ *
+ *
+ * 不分页：一所学校 + 平台级里可填的表单是个位数到几十张（P95 W3 的量级假设，报告已记），
+ * 一张轻列表不值得引入游标；返回值就是裸数组，不带 total——将来真长大了加分页时不破坏"行形状"这条契约。
+ *
+ * 与数据面的关系：本类只回答"入口给谁开"，不看 {@link DataScopeService}。
+ * 列表里出现某张表单，不代表进去能看到别人的行（层②教师看到的仍是仅本人提交）。
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class FillableFormService {
+
+ private static final DateTimeFormatter TS = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+ private final FormRepository formRepository;
+ private final FillAccessService fillAccess;
+
+ /**
+ * 我可填清单。
+ *
+ * @param appCode 可选；空/缺省=全部应用（中心 + 所有快应用），非空=只要该 app_code 下的表单
+ * @return 已按 deadline/code 排好序的行集；无权限的人拿到的是空集而不是异常
+ */
+ public List listFillable(BoaUser user, String appCode) {
+ Long schId = requireSessionSchId(user);
+ String cleanApp = appCode == null ? "" : appCode.trim();
+ List domain = Form.PLATFORM_SCH_ID == schId
+ ? Collections.singletonList(Form.PLATFORM_SCH_ID)
+ : Arrays.asList(schId, Form.PLATFORM_SCH_ID);
+
+ // 先按 (app_code, code) 分组，再逐组走遮蔽规则——resolve 是"一个 code 一次判定"，
+ // 列表要把同一条判定摊到多个 code 上，分组就是这条摊法（不是另写一份遮蔽逻辑）
+ Map> groups = new LinkedHashMap<>();
+ for (Form form : formRepository.findPublishedInDomain(domain)) {
+ if (!cleanApp.isEmpty() && !cleanApp.equals(form.getAppCode())) {
+ continue;
+ }
+ String key = form.getAppCode() + "#" + form.getCode();
+ List