P4-1 转换器线:扩 EDITFORM/主子表/树/选择窗/<report> 段 + 全量 1516 模板批量转换双闸分级

转换器扩展(platform-converter,PoC crud 三段种子上):
- 按 XML 根元素分派 crud/form/tree/report/group;ConversionResult+Grade 三级分级
- EDITFORM:form pageid 解析 view_page 取字段;主子表 EditGrid/FormEditGrid→input-table(子列取自 editgridtemplate)
- 树:type=3 声明式→input-tree、type=4 引用式→flex(tree+crud)
- 选择窗 SelectDialog/MultiSelectDialog→select+source(非 amis picker:picker 不在 6.13 schema 表单项 oneOf,闸一会拒)
- <report> A 类:crud+合计行(issummer→summaryFields)+金额列(ismoney→number);selectservice→/api/flow;JOR/图表降级标注
- UiTypeMapper 统一 uitype 映射;每决策登记映射台账(全量约 1.6 万条)
- 孤儿模板(entityid 非法/空 xml)旁路标记不崩(手册 §7.4)

批量+双闸(BatchConvertCli,可独立 CLI 跑批,只读连库+5435 ceshi 库硬守门):
- 闸一 SchemaGate(宽松语义预处理抽出,与 AmisSchemaController 共享):通过 98.2%(1489/1516)
- 闸二 playwright+本地 amis SDK 渲染冒烟,每类型抽≥5:25/25 全过
- 产物 转换产物/(schema/*.json + 分级清单.csv + 闸二结果.json)
- 失败 27 个全为空 xml 孤儿模板(库内数据问题,非转换器缺陷)

新坑进手册 §8.3(picker 不在表单项 oneOf,用 select+source) §8.4(闸二大 schema 经端点拉避 HTTP 431)
单测 24 个;全 reactor mvn test+ArchUnit 绿
报告 platform-converter/P4批量转换报告.md

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
2026-06-11 16:27:49 +08:00
parent aefb0e2eb9
commit f563b472e6
20 changed files with 37747 additions and 167 deletions

View File

@@ -653,6 +653,24 @@ com.dsasp.* com.eip4.*
| **对策** | **双闸缺一不可**:第一闸(schema 校验)抓结构问题;第二闸(headless 渲染冒烟,如 Puppeteer/Playwright 执行 `amis.embed`)抓渲染问题;P4 批量转换流水线必须两闸串联,两闸都过才入库 | | **对策** | **双闸缺一不可**:第一闸(schema 校验)抓结构问题;第二闸(headless 渲染冒烟,如 Puppeteer/Playwright 执行 `amis.embed`)抓渲染问题;P4 批量转换流水线必须两闸串联,两闸都过才入库 |
| **影响范围** | P4 全量 1,516 模板转换流水线;AI 生成管线;MCP Server validate-schema(需升级为双闸);决策会已将「双闸」作为质量门禁第 2 条 | | **影响范围** | P4 全量 1,516 模板转换流水线;AI 生成管线;MCP Server validate-schema(需升级为双闸);决策会已将「双闸」作为质量门禁第 2 条 |
### 8.3 amis `picker` 表单项不在 6.13 schema 的表单项 oneOf 中(弹窗选择器映射坑)[NEW 2026-06-11]
| 栏目 | 内容 |
|------|------|
| **现象** | P4 批量转换把旧引擎 `uitype=SelectDialog` 弹窗选择器映射为 amis `picker` 控件后,**闸一 schema 校验大批失败**,错误为 `$.body.body: array found, object expected`(form 含 ≥3 表单项时爆发);但 picker 在浏览器实际能渲染 |
| **根因** | amis 6.13 官方 schema 中 `PickerControlSchema`(type const "picker")虽存在,但**未被纳入表单项的 oneOf 分支**;form.body 数组里出现 picker 时,校验器走不到 picker 分支、回落到把整个 form.body 当单对象(SchemaNode)的分支并报「array found, object expected」。这是 schema 枚举不全,非 schema 严格性问题 |
| **对策** | 弹窗选择器(SelectDialog/MultiSelectDialog)**映射为 `select` + 远程 `source`**(multiple 对应多选),而非 picker——select+source 双闸皆过且语义保真(弹窗本质是远程数据选择)。picker 需内嵌 pickerSchema(CRUD)、跨模板引用,本就无法在单模板转换内自洽。**实测此一项把闸一通过率从 94.7% → 98.2%** |
| **影响范围** | P4 转换器 uitype 映射表(已落 `UiTypeMapper`);任何把"弹窗选择"类旧控件转 amis 表单项的地方;AI 生成管线若生成 picker 表单项同样会被闸一拒,应优先用 select+source |
### 8.4 闸二渲染冒烟宿主:大 schema 不可经 URL query 注入(HTTP 431 坑)[NEW 2026-06-11]
| 栏目 | 内容 |
|------|------|
| **现象** | P4 闸二 playwright 渲染冒烟,个别大模板(字段多、schema 大)被误判「根组件未渲染出 DOM」;实为宿主 HTML 自身加载失败 |
| **根因** | 冒烟宿主把 schema JSON 经 `?schema=<urlencoded>` 塞进 URL,大 schema 撑爆 HTTP 请求头,Node 静态服务器返回 **431 Request Header Fields Too Large**,host.html 根本没加载 |
| **对策** | schema 经**独立端点**(`/schema?id=<模板id>` 后端读文件返回)拉取,URL 只传短 id;宿主 `fetch('/schema?id=…')` 后再 `amis.embed`。改后该类模板渲染恢复正常(form 抽样 4/5 → 5/5) |
| **影响范围** | P4 闸二冒烟宿主(已修,见 `platform-converter/gate2-smoke/{host.html,smoke.mjs}`);任何用 query 串传 schema 给 headless 宿主的渲染验证脚本 |
--- ---
## 九、待补章节占位 ## 九、待补章节占位

View File

@@ -0,0 +1,173 @@
# P4 批量转换报告(模板转换器扩展 + 全量批量转换 + 双闸分级)
> 日期:2026-06-11 | 作者:platform-converter 工作线
> 数据源:客户库 192.168.20.68:5435/postgres?currentSchema=eip3(ceshi/ceshi,**只读**)
> 工程:eip4-platform/platform-converter(JDK17)
> 前序:PoC 种子 `TemplateToAmisConverter`(display/search/button 三段,3 模板 0 错误已验证)
> 依据:docs/迁移手册.md §8(amis schema 宽松语义预处理、双闸必要性、dom4j getText)、
> ../docs/决策与盘点/EIP3报表迁移方案.md(A 类报表=`<report>` 段口径)
---
## 一、一句话结论
全量 **1,516** 个 view_template 批量转换:**闸一(官方 schema 校验)通过率 98.2%(1489/1516)**;
闸二(headless 渲染冒烟,每类型抽 ≥5)**25/25 全通过**。
未过闸一的 27 个全部是 **xml 为空的孤儿模板**(库内数据问题,非转换器缺陷),转换器对其旁路标记不崩。
通过率数字 98.2% 即检查点②(首功能点切流)的输入。
---
## 二、总量与各类型分布
模板按 XML 根元素分派转换(根元素与 view_template.type 一一对应):
| 根元素 | 类型语义 | 总量 | 闸一通过 | 通过率 | SUCCESS | PARTIAL | FAILED |
|--------|---------|-----:|--------:|------:|--------:|--------:|-------:|
| crud | GRID 列表页 | 956 | 956 | 100.0% | 259 | 697 | 0 |
| report | A 类表格式报表 | 337 | 337 | 100.0% | 0 | 337 | 0 |
| tree | 树 / 树+grid | 106 | 106 | 100.0% | 0 | 106 | 0 |
| form | EDITFORM 表单页 | 70 | 70 | 100.0% | 0 | 70 | 0 |
| group | 分组容器 | 20 | 20 | 100.0% | 0 | 20 | 0 |
| (空 xml) | 孤儿模板 | 27 | 0 | 0.0% | 0 | 0 | 27 |
| **合计** | | **1516** | **1489** | **98.2%** | **259** | **1230** | **27** |
> 分级口径:
> - **SUCCESS**:全字段命中映射规则,无降级标注,闸一通过。
> - **PARTIAL**:转出有效 amis schema 且闸一通过,但有字段/特性走降级旁路(标注在映射台账)。
> - **FAILED**:无法转出(xml 为空 / 解析失败 / 根元素不支持),不入产物只入失败清单。
>
> report/tree/form/group 全部落 PARTIAL 是设计内:report 普遍含 JOR 套打版式(C 类不迁移)、
> tree 普遍含节点级按钮、form 普遍含 SelectDialog/自定义 HTML 版式、group 全为跨模板壳——
> 这些都是「能渲染、待后端/人工补」的降级,不是错误。
---
## 三、双闸结果
### 闸一:官方 schema 校验(amis-schema-6.13.0.json,draft-07)
- 通过 **1489/1516 = 98.2%**。
- 复用迁移手册 §8.1 的**宽松语义预处理**(递归剥除 `$ref` 节点的兄弟 `additionalProperties:false`),
实现抽到 `platform-converter/SchemaGate`,与 `AmisSchemaController` 共享同一份口径(消除 metadata 侧重复实现)。
- 失败 27 个全部因 xml 为空,无 schema 可校验。
### 闸二:headless 渲染冒烟(playwright + 本地 amis SDK 6.13.0)
口径:对每个模板类型从**闸一通过**的 schema 中抽 **≥5** 个,用本地 amis SDK(`../eip4-poc/.../sdk-local/`)+
无头 chromium 逐个 `amis.embed` 渲染,判定 ① 无未捕获 JS 错误 ② 根组件渲染出 DOM(#root 有子节点)。
数据接口全部桩成空响应(冒烟只验「能渲染根组件」,不验数据)。**全量渲染不要求——本闸是抽样冒烟。**
| 类型 | 抽样 | 通过 | 失败 |
|------|----:|----:|----:|
| crud | 5 | 5 | 0 |
| report | 5 | 5 | 0 |
| tree | 5 | 5 | 0 |
| form | 5 | 5 | 0 |
| group | 5 | 5 | 0 |
| **合计** | **25** | **25** | **0** |
> 闸二坑(已修,记入手册):大 schema 经 URL query 注入触发 **HTTP 431 (Request Header Fields Too Large)**,
> 误判为「根组件未渲染」。改为 schema 经独立 `/schema?id=` 端点拉取后,form 抽样从 4/5 → 5/5。
产物:`转换产物/闸二结果.json`(含逐样本判定)。
---
## 四、失败模式 Top10(按模板计,去重原因)
| # | 模板数 | 归类 | 模式 |
|---|------:|------|------|
| 1 | 937 | 转换器缺陷(待补能力) | search 字段 uitype=SelectDialog → select+source 占位(弹窗数据源 /api/picker 待后端实现) |
| 2 | 329 | C 类设计内不迁移 | report 含 reportfile(JOR 套打版式)→ 仅转表格视图,套打另案 univer/Web 打印 |
| 3 | 138 | 转换器缺陷(待补能力) | search 字段 uitype=MultiSelectDialog → select(multiple)+source 占位 |
| 4 | 69 | 模板版式 | form 含 HTML `<layout>` 自定义表格版式 → amis 默认纵向布局替代,版式需人工核对 |
| 5 | 61 | 转换器缺陷(待补能力) | tree 节点含 buttons(增删改保存)→ input-tree 不原生支持节点级按钮,需自定义工具栏 |
| 6 | 50 | 转换器缺陷(待补能力) | editform 字段 uitype=SelectDialog → select+source 占位 |
| 7 | 41 | 转换器缺陷(待补能力) | editform 字段 uitype=MultiFileUploadField → 暂映射 input-text(映射表待补该控件) |
| 8 | 27 | **模板数据问题** | xml 为空(孤儿模板,FAILED) |
| 9 | 26 | 主子表已支持 | editform 字段 uitype=EditGrid → input-table 子表(保存联动 updateSubTable 待后端) |
| 10 | 20 | 跨模板引用 | group 分组容器仅转 tabs 壳,各 tab 子模板需跨模板联动加载 |
**三桶归类(按模板计)**:
| 桶 | 模板数 | 说明 |
|----|------:|------|
| 转换器缺陷(待补能力) | 1228 | 绝大多数是 SelectDialog→数据源未联动、JOR 套打、跨模板引用等「schema 有效、待后端/人工补」项,**非渲染缺陷** |
| 模板数据问题 | 28 | xml 为空(27)+ 个别解析问题,库内存量数据缺陷 |
| 孤儿模板(entityid 非法) | 5 | entityid 在 SYS_ENTITY 无对应实体(迁移手册 §7.4),转换器旁路标记不崩 |
> 关键判读:「转换器缺陷」桶 1228 个里,**937+138+50=1125 个其实是同一件事**——SelectDialog/MultiSelectDialog
> 弹窗数据源 `/api/picker/{dialogid}/list` 尚未由后端实现。schema 本身有效且渲染通过,属「待联动」而非「转不出」。
> 真正需要补转换器映射规则的只有 MultiFileUploadField(41)等少数控件。
---
## 五、转换器扩展明细(PoC 种子 → P4)
在 PoC 已验证的 crud 三段(display/search/button)上扩出五类根元素分派:
| 段 | 旧形态 | amis 映射 | 备注 |
|----|--------|----------|------|
| **crud** | `<crud><display><field>` | crud columns | 强化 null-safe、金额列(ismoney)→number+千分位、对齐、top-level+display 双挂 button |
| **EDITFORM** | `<form pageid=…>` + view_page 的 `<fields>` | form + body items | 字段经 pageid 解析 view_page 取得;method→form actions |
| **主子表** | form 内 `uitype=EditGrid/FormEditGrid` | **input-table** + 子列 | 子列解析 `<editgridtemplate>` CDATA 内 `<editgrid><field>` |
| **树** | `<tree><node selectservice>` / `<tree><treetemplate ref/><gridtemplate ref/>` | input-tree / flex(tree+crud) | type=3 声明式 / type=4 引用式两路 |
| **picker(选择窗)** | `uitype=SelectDialog/MultiSelectDialog` | **select + 远程 source** | 不用 amis picker——picker 需内嵌 pickerSchema 且 6.13 schema 未纳入表单项 oneOf,闸一会拒(§8.2);select+source 双闸皆过,更保真 |
| **`<report>`(A 类)** | `<report><display><search selectservice>` | crud + 合计行/金额列 | issummer=true→summaryFields、ismoney→number;selectservice→`/api/flow/{id}`;JOR reportfile/图表降级标注(B/C 类另案) |
| **group** | `<group><template tempid>` | tabs 壳 | 子模板跨引用,本批不联动 |
uitype 映射全集(客户库实测):TextField→input-text、TextArea→textarea、NumberField→input-number、
CheckBox→checkbox、ComboBox→select+字典 source、PopupDateField→input-date(time)、
DoublePopupDateField→input-date(time)-range、SelectDialog/MultiSelectDialog→select+source、
EditGrid/FormEditGrid→input-table、未知→input-text(降级标注)。
---
## 六、映射台账
- **规模**:全量 1,516 模板共登记约 **15,973 条**映射决策(每条= 一个字段/按钮/特性的映射或降级标注)。
- **载体**:逐模板的 mappingNotes(CLI 内存),CSV `分级清单.csv` 落每模板的台账条数与原因归类;
单模板完整台账可经 `GET /api/poc/amis-validate?template=<名>` 在线复现(PoC 既有接口)。
- **降级标注**:所有「做不到的字段/特性」均以 `[降级]` 前缀进台账并归三桶,CSV 「reasons」列可直接做人工抽检挑样。
---
## 七、与「人工抽检分级」的衔接(给人工抽检挑样建议)
1. **优先抽 SUCCESS 段做正例对拍**(259 个 crud):无降级,schema 应与旧 GRID 行为最接近,适合做转换正确性基线。
2. **PARTIAL 按降级原因分层抽**:
- 报表合计行(issummer,CSV 含 summaryFields 的 report)——**数值正确性必须人工核对**(报表迁移方案风险 2:算错数比难看严重)。
- SelectDialog/MultiSelectDialog 密集模板——验「数据源联动后」可用性,是后端 `/api/picker` 实现的验收样本。
- EditGrid 主子表模板(26 个)——验子表 input-table 渲染 + 后续 updateSubTable 保存联动。
3. **FAILED 27 个孤儿模板**:交客户定性(废弃归档 / 重建 / 仍在用),决策会红线 3,**需客户书面确认**后才知是否纳入切流分母。
4. **挑样工具**:`分级清单.csv`(UTF-8 BOM,Excel 可直接打开)按 grade/root/reasons 三列过滤即可成挑样清单。
---
## 八、产物清单
| 产物 | 路径 | 说明 |
|------|------|------|
| 转换 schema(按模板 id 命名) | `转换产物/schema/{view_template_id}.json` | 1489 个(闸一通过的全部落盘) |
| 分级清单 | `转换产物/分级清单.csv` | 1516 行 + 表头:id/名称/type/根元素/分级/闸一/台账条数/原因归类 |
| 闸二冒烟结果 | `转换产物/闸二结果.json` | 逐样本判定 + 各类型汇总 |
| 转换器 | `src/main/java/.../TemplateToAmisConverter.java` 等 5 个类 | 分派/分级/uitype 映射/闸一 |
| CLI 跑批 | `BatchConvertCli`(可独立 java -cp 运行) | 只读连库 + 5435 ceshi 库硬守门 |
| 闸二冒烟脚本 | `gate2-smoke/{smoke.mjs,host.html}` | playwright + 本地 SDK,最小 HTML 宿主 |
复跑命令(JDK17):
```
mvn -pl platform-converter dependency:build-classpath -Dmdep.outputFile=/tmp/cp.txt
java -cp "target/classes:$(cat /tmp/cp.txt)" com.eip4.platform.converter.BatchConvertCli
cd gate2-smoke && npm install && npx playwright install chromium && node smoke.mjs
```
---
## 九、复跑/口径备注
- **只读红线**:CLI `conn.setReadOnly(true)`;URL 硬校验 dbname=postgres,连 dbname=ceshi 直接抛错拒启(5435 上不完整的 ceshi 库严禁连)。
- **dom4j getText**:脚本文本一律 `getText()` 保留 Groovy 换行(手册 §5.3),台账登记处已遵循。
- **闸一预处理唯一来源**:SchemaGate,避免「所有 ajv 校验处」(手册 §8.1)各写一份漂移。
- 单测 **24 个**(各段转换规则 + 闸一 + CLI 守门/归类),全模块 `mvn test` + ArchUnit 绿(10 模块 BUILD SUCCESS)。

View File

@@ -0,0 +1,2 @@
node_modules/
package-lock.json

View File

@@ -0,0 +1,43 @@
<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="utf-8"/>
<title>P4 闸二 · amis 渲染冒烟(本地 SDK 6.13.0)</title>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<!-- amis SDK 6.13.0 本地构建产物(不依赖 CDN);路径经静态服务器映射到 /sdk-local -->
<link rel="stylesheet" href="/sdk-local/sdk.css"/>
<link rel="stylesheet" href="/sdk-local/helper.css"/>
<link rel="stylesheet" href="/sdk-local/iconfont.css"/>
<script src="/sdk-local/sdk.js"></script>
<style>html,body,#root{height:100%;margin:0}</style>
</head>
<body>
<div id="root"></div>
<script>
// schema 经查询参数 ?schema=<urlencoded-json> 注入(冒烟脚本逐个填)
window.__amisRenderError = null;
window.addEventListener('error', function (e) {
window.__amisRenderError = String(e.message || e.error || e);
});
// schema 经 /schema?id=<模板id> 拉取(避免大 schema 撑爆 URL header,HTTP 431)
(function () {
const id = new URLSearchParams(location.search).get('id');
fetch('/schema?id=' + encodeURIComponent(id))
.then(function (r) { return r.json(); })
.then(function (schema) {
const amis = amisRequire('amis/embed');
amis.embed('#root', schema, {}, {
// 数据接口全部桩成空响应:冒烟只验「能渲染根组件」,不验数据
fetcher: function () {
return Promise.resolve({ status: 200, data: { status: 0, msg: '', data: { items: [], total: 0 } } });
}
});
window.__amisEmbedded = true;
})
.catch(function (err) {
window.__amisRenderError = 'embed 异常: ' + (err && err.stack || err);
});
})();
</script>
</body>
</html>

View File

@@ -0,0 +1,7 @@
{
"name": "p4-gate2-smoke",
"private": true,
"type": "module",
"description": "P4 闸二 amis 渲染冒烟(抽样自动化)",
"dependencies": { "playwright": "1.60.0" }
}

View File

@@ -0,0 +1,142 @@
// P4 闸二:amis 渲染冒烟(抽样自动化)。
//
// 口径:对每个模板类型(crud/form/tree/report/group)从闸一通过的 schema 中抽 ≥N(默认 5)个,
// 用本地 amis SDK 6.13.0 + 无头 chromium(playwright)逐个渲染,判定:
// ① 无未捕获 JS 错误(window.__amisRenderError 为空);
// ② 根组件渲染出 DOM(#root 有子节点)。
// 全量渲染不要求——本脚本是抽样冒烟,样本与判定写进 闸二结果.json。
//
// 用法:node smoke.mjs [产物目录=../转换产物] [每类型样本数=5]
import http from 'node:http';
import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { chromium } from 'playwright';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const OUT_DIR = path.resolve(__dirname, process.argv[2] || '../转换产物');
const PER_TYPE = parseInt(process.argv[3] || '5', 10);
const SDK_DIR = path.resolve(__dirname,
'../../../eip4-poc/src/main/resources/static/sdk-local');
const SCHEMA_DIR = path.join(OUT_DIR, 'schema');
const CSV = path.join(OUT_DIR, '分级清单.csv');
// ── 从 CSV 选样:每个 root 抽 PER_TYPE 个闸一通过(gate1=true)的模板 ──────────
function pickSamples() {
const lines = fs.readFileSync(CSV, 'utf8').replace(/^/, '').split('\n').filter(Boolean);
lines.shift(); // 表头
const byRoot = {};
for (const line of lines) {
// CSV 首列 id、4 列 root、5 列 grade、6 列 gate1;用简易解析(前 6 列无逗号转义风险)
const cols = line.split(',');
const id = cols[0], root = cols[3], gate1 = cols[5];
if (gate1 !== 'true') continue;
if (!byRoot[root]) byRoot[root] = [];
if (byRoot[root].length < PER_TYPE) byRoot[root].push(id);
}
return byRoot;
}
// ── 最小静态服务器:/host.html + /sdk-local/* ────────────────────────────────
function startServer() {
const types = {
'.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
'.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf',
'.eot': 'application/vnd.ms-fontobject', '.svg': 'image/svg+xml',
'.png': 'image/png', '.json': 'application/json'
};
const server = http.createServer((req, res) => {
const [urlPathRaw, query] = req.url.split('?');
const urlPath = decodeURIComponent(urlPathRaw);
// schema 经独立端点拉取(避免大 schema 进 URL header 触发 HTTP 431)
if (urlPath === '/schema') {
const id = new URLSearchParams(query || '').get('id');
const file = path.join(SCHEMA_DIR, id + '.json');
fs.readFile(file, (err, buf) => {
if (err) { res.writeHead(404); res.end('{}'); return; }
res.writeHead(200, { 'Content-Type': 'application/json' });
res.end(buf);
});
return;
}
let file;
if (urlPath === '/host.html' || urlPath === '/') {
file = path.join(__dirname, 'host.html');
} else if (urlPath.startsWith('/sdk-local/')) {
file = path.join(SDK_DIR, urlPath.replace('/sdk-local/', ''));
} else {
res.writeHead(404); res.end('not found'); return;
}
fs.readFile(file, (err, buf) => {
if (err) { res.writeHead(404); res.end('not found: ' + file); return; }
res.writeHead(200, { 'Content-Type': types[path.extname(file)] || 'application/octet-stream' });
res.end(buf);
});
});
return new Promise(resolve => server.listen(0, () => resolve(server)));
}
async function run() {
const samples = pickSamples();
const server = await startServer();
const port = server.address().port;
const browser = await chromium.launch({ headless: true });
const results = { perType: {}, samples: [], generatedAt: new Date().toISOString(), perTypeTarget: PER_TYPE };
for (const [root, ids] of Object.entries(samples)) {
if (root === '(null-xml)') continue;
results.perType[root] = { sampled: 0, pass: 0, fail: 0 };
for (const id of ids) {
const schemaPath = path.join(SCHEMA_DIR, id + '.json');
if (!fs.existsSync(schemaPath)) continue;
const url = `http://127.0.0.1:${port}/host.html?id=${encodeURIComponent(id)}`;
const page = await browser.newPage();
const consoleErrors = [];
page.on('console', m => { if (m.type() === 'error') consoleErrors.push(m.text()); });
page.on('pageerror', e => consoleErrors.push(String(e)));
let pass = false, reason = '';
try {
await page.goto(url, { waitUntil: 'networkidle', timeout: 20000 });
// 等根组件渲染出 DOM
await page.waitForFunction(
() => document.querySelector('#root') && document.querySelector('#root').children.length > 0,
{ timeout: 8000 }
).catch(() => {});
const state = await page.evaluate(() => ({
err: window.__amisRenderError,
rootChildren: document.querySelector('#root') ? document.querySelector('#root').children.length : 0
}));
// 过滤已知无害噪声(字体 404、桩接口告警不算渲染错误)
const fatal = consoleErrors.filter(e =>
!/iconfont|\.woff|\.ttf|favicon|Failed to load resource/i.test(e));
if (state.err) { reason = 'JS错误:' + state.err; }
else if (state.rootChildren === 0) { reason = '根组件未渲染出 DOM'; }
else if (fatal.length) { reason = 'console错误:' + fatal[0].slice(0, 120); }
else { pass = true; }
} catch (e) {
reason = '导航/渲染超时: ' + String(e).slice(0, 100);
}
await page.close();
results.perType[root].sampled++;
results.perType[root][pass ? 'pass' : 'fail']++;
results.samples.push({ root, id, pass, reason });
process.stdout.write(`${root} ${id}: ${pass ? 'PASS' : 'FAIL ' + reason}\n`);
}
}
await browser.close();
server.close();
fs.writeFileSync(path.join(OUT_DIR, '闸二结果.json'), JSON.stringify(results, null, 2), 'utf8');
console.log('\n=== 闸二渲染冒烟汇总(抽样)===');
for (const [root, r] of Object.entries(results.perType)) {
console.log(` ${root}: 抽样 ${r.sampled},通过 ${r.pass},失败 ${r.fail}`);
}
}
run().catch(e => { console.error(e); process.exit(1); });

View File

@@ -14,6 +14,10 @@
<dependencies> <dependencies>
<dependency><groupId>com.eip4</groupId><artifactId>platform-legacy-core</artifactId></dependency> <dependency><groupId>com.eip4</groupId><artifactId>platform-legacy-core</artifactId></dependency>
<dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId></dependency> <dependency><groupId>com.fasterxml.jackson.core</groupId><artifactId>jackson-databind</artifactId></dependency>
<!-- 闸一:amis 官方 schema.json(draft-07)机器校验(宽松语义预处理见 SchemaGate) -->
<dependency><groupId>com.networknt</groupId><artifactId>json-schema-validator</artifactId></dependency>
<!-- CLI 跑批从客户库(PostgreSQL)只读拉模板;独立可执行,不经 Boot 自动装配 -->
<dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency> <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
</dependencies> </dependencies>
</project> </project>

View File

@@ -0,0 +1,257 @@
package com.eip4.platform.converter;
import java.io.IOException;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Function;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.SingleConnectionDataSource;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
/**
* P4 批量转换 CLI(架构第一节定位:转换器可独立运行,不经 Boot 自动装配)。
*
* <p>流程:从客户库(PostgreSQL,只读)拉全部 view_template.xml → 逐个 {@link TemplateToAmisConverter}
* 转换 → 闸一 {@link SchemaGate} 官方 schema 校验 → 产物落盘 + 分级清单 CSV。
*
* <p>用法:
* <pre>{@code
* java -cp ... com.eip4.platform.converter.BatchConvertCli \
* "jdbc:postgresql://192.168.20.68:5435/postgres?currentSchema=eip3" ceshi ceshi 转换产物
* }</pre>
* 参数缺省即上述客户库(只读)。⚠️ 5435 上有个不完整的 ceshi 库——严禁连 dbname=ceshi;本 CLI 硬校验
* URL 必须 dbname=postgres,否则拒绝启动。
*/
public final class BatchConvertCli {
private static final String DEFAULT_URL =
"jdbc:postgresql://192.168.20.68:5435/postgres?currentSchema=eip3";
private static final String DEFAULT_USER = "ceshi";
private static final String DEFAULT_PASS = "ceshi";
private static final String DEFAULT_OUT = "转换产物";
private BatchConvertCli() {
}
public static void main(String[] args) throws Exception {
String url = args.length > 0 ? args[0] : DEFAULT_URL;
String user = args.length > 1 ? args[1] : DEFAULT_USER;
String pass = args.length > 2 ? args[2] : DEFAULT_PASS;
Path outDir = Path.of(args.length > 3 ? args[3] : DEFAULT_OUT);
guardUrl(url);
Connection conn = DriverManager.getConnection(url, user, pass);
conn.setReadOnly(true); // 只读保护(任务红线)
conn.setAutoCommit(true);
try {
BatchSummary summary = run(conn, outDir);
System.out.println(summary.render());
} finally {
conn.close();
}
}
/** dbname 必须是 postgres——拦住误连 5435 上不完整的 ceshi 库(任务红线)。 */
static void guardUrl(String url) {
String afterHost = url.replaceFirst("^jdbc:postgresql://[^/]+/", "");
String db = afterHost.split("[?]", 2)[0];
if (!"postgres".equals(db)) {
throw new IllegalArgumentException(
"拒绝连接:dbname=" + db + ",只允许 dbname=postgres(5435 上有不完整的 ceshi 库,严禁连)");
}
}
static BatchSummary run(Connection conn, Path outDir) throws IOException, SQLException {
Path schemaDir = outDir.resolve("schema");
Files.createDirectories(schemaDir);
JdbcTemplate jdbc = new JdbcTemplate(new SingleConnectionDataSource(conn, true));
TemplateToAmisConverter converter = new TemplateToAmisConverter(jdbc);
SchemaGate gate = new SchemaGate();
Function<String, String> pageResolver = pageId -> loadPageXml(conn, pageId);
ObjectMapper json = new ObjectMapper();
json.enable(SerializationFeature.INDENT_OUTPUT);
BatchSummary summary = new BatchSummary();
List<String[]> csvRows = new ArrayList<>();
// CSV 表头:模板id,名称,type,根元素,分级,闸一(schema),映射条数,原因归类
csvRows.add(new String[]{"view_template_id", "name", "type", "root", "grade",
"gate1_schema_valid", "mapping_notes", "reasons"});
String sql = "SELECT view_template_id, name, type, xml::text AS xmltext "
+ "FROM view_template ORDER BY type, view_template_id";
try (PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery()) {
while (rs.next()) {
String id = rs.getString("view_template_id").trim();
String name = rs.getString("name");
int type = rs.getInt("type");
String xml = rs.getString("xmltext");
if (xml == null || xml.isBlank()) {
summary.record("(null-xml)", ConversionGrade.FAILED, false);
csvRows.add(new String[]{id, name, String.valueOf(type), "(null-xml)",
"FAILED", "false", "0", "模板数据问题:xml 为空(孤儿模板)"});
continue;
}
List<String> notes = new ArrayList<>();
ConversionResult result = converter.convertGraded(xml, notes, pageResolver);
boolean gate1 = false;
if (result.getSchema() != null) {
List<String> errors = gate.validate(result.getSchema());
gate1 = errors.isEmpty();
if (!gate1) {
// schema 校验失败也是一种降级原因,登记进归类(不改原 grade 的转换语义,单列闸一结果)
result.getDegrades().add("闸一 schema 校验未过: "
+ String.join(" | ", errors.subList(0, Math.min(3, errors.size()))));
}
// 产物落盘(schema json 按模板 id 命名)
Files.writeString(schemaDir.resolve(id + ".json"),
json.writeValueAsString(result.getSchema()), StandardCharsets.UTF_8);
}
ConversionGrade effective = effectiveGrade(result.getGrade(), gate1);
summary.record(result.getRootElement(), effective, gate1);
csvRows.add(new String[]{
id, name, String.valueOf(type), result.getRootElement(),
effective.name(), String.valueOf(gate1),
String.valueOf(result.getMappingNotes().size()),
classifyReasons(result)});
}
}
writeCsv(outDir.resolve("分级清单.csv"), csvRows);
return summary;
}
/** 闸一不过 → 即便转换 SUCCESS 也降为 PARTIAL(双闸缺一不可,手册 §8.2)。 */
private static ConversionGrade effectiveGrade(ConversionGrade convertGrade, boolean gate1) {
if (convertGrade == ConversionGrade.FAILED) {
return ConversionGrade.FAILED;
}
return gate1 ? convertGrade : ConversionGrade.PARTIAL;
}
/** 把降级原因归类成三桶之一(转换器缺陷 / 模板数据问题 / 孤儿模板),便于 Top10 统计。 */
static String classifyReasons(ConversionResult result) {
if (result.getDegrades().isEmpty()) {
return "";
}
List<String> tags = new ArrayList<>();
for (String d : result.getDegrades()) {
tags.add(bucket(d) + ":" + d.replace(",", ","));
}
return String.join(" | ", tags);
}
static String bucket(String degrade) {
if (degrade.contains("孤儿") || degrade.contains("SYS_ENTITY 无对应") || degrade.contains("entityid")) {
return "孤儿模板";
}
if (degrade.contains("xml 为空") || degrade.contains("解析失败") || degrade.contains("无法解析 view_page")) {
return "模板数据问题";
}
// picker/子表/跨模板/JOR/图表 等本批未实现的能力 → 归转换器缺陷(待补能力)
return "转换器缺陷";
}
private static void writeCsv(Path path, List<String[]> rows) throws IOException {
try (Writer w = Files.newBufferedWriter(path, StandardCharsets.UTF_8)) {
w.write(''); // BOM,便于 Excel 识别 UTF-8 中文
for (String[] row : rows) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < row.length; i++) {
if (i > 0) {
sb.append(',');
}
sb.append(csvCell(row[i]));
}
sb.append('\n');
w.write(sb.toString());
}
}
}
private static String csvCell(String v) {
if (v == null) {
return "";
}
if (v.contains(",") || v.contains("\"") || v.contains("\n")) {
return '"' + v.replace("\"", "\"\"") + '"';
}
return v;
}
private static String loadPageXml(Connection conn, String pageId) {
if (pageId == null || pageId.isBlank()) {
return null;
}
try (PreparedStatement ps = conn.prepareStatement(
"SELECT xml::text FROM view_page WHERE view_page_id=? AND xml IS NOT NULL")) {
ps.setString(1, pageId);
try (ResultSet rs = ps.executeQuery()) {
return rs.next() ? rs.getString(1) : null;
}
} catch (SQLException e) {
return null;
}
}
/** 跑批统计累加器:总量 + 各根元素分布 + 分级 + 闸一通过率。 */
static final class BatchSummary {
int total;
int gate1Pass;
final Map<ConversionGrade, Integer> grades = new LinkedHashMap<>();
final Map<String, int[]> byRoot = new TreeMap<>(); // root → [total, gate1Pass]
void record(String root, ConversionGrade grade, boolean gate1) {
total++;
grades.merge(grade, 1, Integer::sum);
if (gate1) {
gate1Pass++;
}
int[] r = byRoot.computeIfAbsent(root, k -> new int[2]);
r[0]++;
if (gate1) {
r[1]++;
}
}
String render() {
StringBuilder sb = new StringBuilder();
sb.append("=== P4 批量转换汇总 ===\n");
sb.append("总量: ").append(total).append('\n');
sb.append("闸一(schema)通过: ").append(gate1Pass)
.append(" (").append(pct(gate1Pass, total)).append(")\n");
sb.append("分级: ");
grades.forEach((g, n) -> sb.append(g).append('=').append(n).append(" "));
sb.append('\n');
sb.append("各根元素 [总量/闸一通过/通过率]:\n");
byRoot.forEach((root, r) -> sb.append(" ").append(root).append(": ")
.append(r[0]).append('/').append(r[1]).append('/').append(pct(r[1], r[0])).append('\n'));
return sb.toString();
}
static String pct(int n, int d) {
return d == 0 ? "0%" : String.format("%.1f%%", n * 100.0 / d);
}
}
}

View File

@@ -0,0 +1,16 @@
package com.eip4.platform.converter;
/**
* 转换分级(P4 双闸分级口径,对应报表迁移方案 A 类「做不到的字段降级标注」)。
*
* <ul>
* <li>{@link #SUCCESS} —— 全字段命中映射规则,无降级标注;</li>
* <li>{@link #PARTIAL} —— 转出有效 amis schema,但有字段/特性走了降级旁路(标注在 mappingNotes / degrades);</li>
* <li>{@link #FAILED} —— 无法转出(孤儿模板 / 根元素不支持 / 解析异常),不入产物只入失败清单。</li>
* </ul>
*/
public enum ConversionGrade {
SUCCESS,
PARTIAL,
FAILED
}

View File

@@ -0,0 +1,76 @@
package com.eip4.platform.converter;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* 单个模板的转换结果(批量跑批的逐模板产物单元)。
*
* <p>携带四样东西,供 CLI 落盘与分级清单使用:
* <ul>
* <li>{@code schema} —— 转出的 amis 页面 schema(FAILED 时为 null);</li>
* <li>{@code grade} —— 分级(success / partial / failed);</li>
* <li>{@code mappingNotes} —— 映射台账逐条登记(PoC 传统,每个映射决策一条);</li>
* <li>{@code degrades} —— 降级标注(PARTIAL/FAILED 的归因,写入 CSV 的「原因」列)。</li>
* </ul>
*/
public class ConversionResult {
private final String rootElement;
private Map<String, Object> schema;
private ConversionGrade grade = ConversionGrade.SUCCESS;
private final List<String> mappingNotes;
private final List<String> degrades = new ArrayList<>();
public ConversionResult(String rootElement, List<String> mappingNotes) {
this.rootElement = rootElement;
this.mappingNotes = mappingNotes;
}
public String getRootElement() {
return rootElement;
}
public Map<String, Object> getSchema() {
return schema;
}
public void setSchema(Map<String, Object> schema) {
this.schema = schema;
}
public ConversionGrade getGrade() {
return grade;
}
public List<String> getMappingNotes() {
return mappingNotes;
}
public List<String> getDegrades() {
return degrades;
}
/** 登记一条映射决策(同时进映射台账)。 */
public void note(String note) {
mappingNotes.add(note);
}
/** 标记一处降级:登记原因并把分级降到 PARTIAL(除非已是 FAILED)。 */
public void degrade(String reason) {
degrades.add(reason);
mappingNotes.add("[降级] " + reason);
if (grade == ConversionGrade.SUCCESS) {
grade = ConversionGrade.PARTIAL;
}
}
/** 标记彻底失败:无 schema 产物,进失败清单。 */
public void fail(String reason) {
degrades.add(reason);
mappingNotes.add("[失败] " + reason);
grade = ConversionGrade.FAILED;
schema = null;
}
}

View File

@@ -0,0 +1,63 @@
package com.eip4.platform.converter;
import java.util.Set;
import java.util.stream.Collectors;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;
/**
* 闸一:amis 官方 schema.json(draft-07)机器校验闭环(迁移手册 §8.1)。
*
* <p>官方 schema 大量使用 {@code {"$ref":..., "additionalProperties":true}} 的兄弟键覆盖写法——这是
* VSCode/Monaco 的宽松合并语义;严格 draft-07 下兄弟键被忽略,被引用定义里的 {@code additionalProperties:false}
* 会拒绝一切输入。预处理:全局剥除 {@code additionalProperties:false},保留类型/必填/结构校验。
*
* <p>「所有使用 ajv 校验 amis schema 的地方都需要这个预处理步骤」(手册 §8.1)——本类把该步骤封进
* platform-converter,供 CLI 跑批与 AmisSchemaController 共享同一份口径。schema 资源同时随 converter
* 与 metadata 打包(CLI 自包含,不反向依赖 metadata)。
*/
public class SchemaGate {
private final ObjectMapper mapper = new ObjectMapper();
private final JsonSchema amisSchema;
public SchemaGate() {
this("/amis-schema-6.13.0.json");
}
public SchemaGate(String classpathResource) {
try {
JsonNode schemaNode = mapper.readTree(getClass().getResourceAsStream(classpathResource));
stripStrictAdditionalProperties(schemaNode);
this.amisSchema = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7).getSchema(schemaNode);
} catch (Exception e) {
throw new IllegalStateException("加载 amis schema 失败: " + classpathResource, e);
}
}
/** 校验一个 amis 页面 schema(Map),返回错误消息列表(空=通过)。 */
public java.util.List<String> validate(Object schema) {
JsonNode node = mapper.valueToTree(schema);
Set<ValidationMessage> errors = amisSchema.validate(node);
return errors.stream().map(ValidationMessage::getMessage).collect(Collectors.toList());
}
private static void stripStrictAdditionalProperties(JsonNode node) {
if (node instanceof ObjectNode obj) {
JsonNode ap = obj.get("additionalProperties");
if (ap != null && ap.isBoolean() && !ap.asBoolean()) {
obj.remove("additionalProperties");
}
obj.properties().forEach(e -> stripStrictAdditionalProperties(e.getValue()));
} else if (node instanceof ArrayNode arr) {
arr.forEach(SchemaGate::stripStrictAdditionalProperties);
}
}
}

View File

@@ -4,6 +4,7 @@ import java.util.ArrayList;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.function.Function;
import org.dom4j.Document; import org.dom4j.Document;
import org.dom4j.DocumentHelper; import org.dom4j.DocumentHelper;
@@ -12,9 +13,20 @@ import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
/** /**
* 模板 XML → amis schema 转换器原型(P4 批量转换器的种子,对应 PoC 方案 4.1.5)。 * 模板 XML → amis schema 转换器(P4 批量转换器)。
* 当前覆盖 GRID(type=1) 模板的 display/search/button 三段; *
* 每个映射决策都登记进 mappingNotes,作为映射表 v0 的数据来源。 * <p>PoC 种子已验证 GRID(crud) 的 display/search/button 三段;P4 在此基础上按根元素分派扩展:
* <ul>
* <li>{@code <crud>} GRID 列表页(含主子表识别)→ amis crud;</li>
* <li>{@code <form>} EDITFORM 表单页 → amis form(字段取自 pageid 指向的 view_page);</li>
* <li>{@code <tree>} 树 / 树+grid → amis tree(type=4 树+grid 走 page+tree+crud);</li>
* <li>{@code <report>} A 类表格式报表(报表迁移方案口径)→ amis crud + 合计行/金额列;</li>
* <li>{@code <group>} 分组容器 → amis tabs 占位(子模板跨引用,本批降级标注)。</li>
* </ul>
*
* <p>每个映射决策登记进 {@link ConversionResult#getMappingNotes()}(PoC 传统映射台账);做不到的字段/特性
* 走 {@link ConversionResult#degrade} 降级标注;孤儿模板(entityid 非法/解析失败)走 {@link ConversionResult#fail}
* 旁路处理,不抛异常终止批量(迁移手册 §7.4)。
*/ */
@Component @Component
public class TemplateToAmisConverter { public class TemplateToAmisConverter {
@@ -25,130 +37,86 @@ public class TemplateToAmisConverter {
this.jdbcTemplate = jdbcTemplate; this.jdbcTemplate = jdbcTemplate;
} }
// ──────────────────────────────────────────────────────────────────────
// 兼容入口:保留 PoC / AmisSchemaController 既有签名(crud 三段)
// ──────────────────────────────────────────────────────────────────────
public Map<String, Object> convert(String templateXml, List<String> mappingNotes) throws Exception { public Map<String, Object> convert(String templateXml, List<String> mappingNotes) throws Exception {
Document doc = DocumentHelper.parseText(templateXml); ConversionResult r = convertGraded(templateXml, mappingNotes, this::loadPageXml);
Element crud = doc.getRootElement(); if (r.getGrade() == ConversionGrade.FAILED) {
if (!"crud".equals(crud.getName())) { throw new IllegalArgumentException(String.join("; ", r.getDegrades()));
throw new IllegalArgumentException("非 crud 模板: " + crud.getName()); }
return r.getSchema();
}
/** 注入 JdbcTemplate 的便捷分级入口(页面 XML 解析器走库内 view_page)。 */
public ConversionResult convertGraded(String templateXml) {
return convertGraded(templateXml, new ArrayList<>(), this::loadPageXml);
}
/**
* 分级转换主入口(批量跑批用)。
*
* @param templateXml view_template.xml 原文
* @param mappingNotes 映射台账累加器
* @param pageResolver pageid → view_page.xml 解析器(form EDITFORM 用;可为 null,缺则降级)
*/
public ConversionResult convertGraded(String templateXml, List<String> mappingNotes,
Function<String, String> pageResolver) {
Document doc;
String root;
try {
doc = DocumentHelper.parseText(templateXml);
root = doc.getRootElement().getName();
} catch (Exception e) {
ConversionResult r = new ConversionResult("(parse-error)", mappingNotes);
r.fail("XML 解析失败: " + e.getClass().getSimpleName() + " " + safeMsg(e));
return r;
} }
ConversionResult result = new ConversionResult(root, mappingNotes);
try {
Element rootEl = doc.getRootElement();
switch (root) {
case "crud" -> result.setSchema(convertCrud(rootEl, result));
case "form" -> result.setSchema(convertForm(rootEl, result, pageResolver));
case "tree" -> result.setSchema(convertTree(rootEl, result));
case "report" -> result.setSchema(convertReport(rootEl, result));
case "group" -> result.setSchema(convertGroup(rootEl, result));
default -> result.fail("不支持的根元素 <" + root + ">(非 crud/form/tree/report/group)");
}
} catch (Exception e) {
result.fail("转换异常: " + e.getClass().getSimpleName() + " " + safeMsg(e));
}
return result;
}
// ──────────────────────────────────────────────────────────────────────
// crud(GRID 列表页)—— PoC 种子规则,强化 null-safe + 主子表识别
// ──────────────────────────────────────────────────────────────────────
private Map<String, Object> convertCrud(Element crud, ConversionResult result) {
String title = crud.attributeValue("title", ""); String title = crud.attributeValue("title", "");
String entityId = crud.attributeValue("entityid", ""); String entityId = crud.attributeValue("entityid", "");
String table = resolveTableName(entityId); String table = resolveTableName(entityId, result);
mappingNotes.add("crud@entityid=" + entityId + " → 实体表 " + table + "(经 SYS_ENTITY 解析)");
// ── display/field → columns // display 可能直接挂 crud,也可能挂 <display> 子元素
List<Map<String, Object>> columns = new ArrayList<>();
Element display = crud.element("display"); Element display = crud.element("display");
if (display != null) { List<Map<String, Object>> columns = display != null ? buildColumns(display, result) : new ArrayList<>();
for (Element f : display.elements("field")) {
String name = f.attributeValue("name", ""); Map<String, Object> filter = buildSearchFilter(crud.element("search"), result);
Map<String, Object> col = new LinkedHashMap<>(); List<Object> toolbar = buildToolbar(collectButtons(crud), table, result);
if (name.endsWith("_DISPLAY__")) {
// 旧引擎的字典/时间翻译列;PoC 先映射回原始列,翻译值待 REST 层补 // 主子表识别:display 段含 <subtemplate>/<detail> 指向子表,或 crud 含 ismaster 标记
String raw = name.substring(0, name.length() - "_DISPLAY__".length()); boolean masterSub = crud.element("subtemplate") != null
col.put("name", raw); || (display != null && display.element("subtemplate") != null);
mappingNotes.add("display@field " + name + " → 原始列 " + raw + "(翻译列,REST 层待补显示值)"); if (masterSub) {
} else { result.degrade("crud 含主子表声明(subtemplate) → 子表渲染需 input-table/嵌套 crud 联动,本批仅转主表列");
col.put("name", name);
}
col.put("label", f.attributeValue("text", name));
String width = f.attributeValue("width");
if (width != null) {
col.put("width", Integer.parseInt(width));
}
if ("true".equals(f.attributeValue("hidden"))) {
col.put("toggled", false);
mappingNotes.add("display@field " + name + " hidden=true → columns-toggler 默认隐藏");
}
columns.add(col);
}
} }
// ── search/field → filter 表单
Map<String, Object> filter = null;
Element search = crud.element("search");
if (search != null && !search.elements("field").isEmpty()) {
List<Map<String, Object>> items = new ArrayList<>();
for (Element f : search.elements("field")) {
String name = f.attributeValue("name", "");
String uitype = f.attributeValue("uitype", "TextField");
Map<String, Object> item = new LinkedHashMap<>();
item.put("name", name);
item.put("label", f.attributeValue("label", name));
switch (uitype) {
case "ComboBox" -> {
item.put("type", "select");
item.put("clearable", true);
String dict = f.attributeValue("comboboxid", "");
item.put("source", "/api/poc/dict/" + dict);
mappingNotes.add("search@field " + name + " uitype=ComboBox(comboboxid=" + dict
+ ") → select + source 字典接口(接口待实现)");
}
case "DateField" -> {
item.put("type", "input-date");
mappingNotes.add("search@field " + name + " uitype=DateField → input-date");
}
default -> {
item.put("type", "input-text");
if (!"TextField".equals(uitype)) {
mappingNotes.add("search@field " + name + " uitype=" + uitype
+ " → 暂映射 input-text(映射表待补该控件)");
}
}
}
items.add(item);
}
filter = new LinkedHashMap<>();
filter.put("title", "查询");
filter.put("body", items);
String script = search.attributeValue("script");
if (script != null && !script.isBlank()) {
mappingNotes.add("search@script 存在(" + script.length() + " 字符)→ 归入脚本分桶处理,本转换器跳过");
}
}
// ── button → headerToolbar
List<Object> toolbar = new ArrayList<>();
toolbar.add("bulkActions");
for (Element b : crud.elements("button")) {
if ("false".equals(b.attributeValue("isshow"))) {
continue;
}
String btnType = b.attributeValue("type", "");
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("label", b.attributeValue("name", b.attributeValue("id", "")));
switch (btnType) {
case "insert" -> {
btn.put("level", "primary");
btn.put("actionType", "dialog");
Map<String, Object> dlg = new LinkedHashMap<>();
dlg.put("type", "dialog");
dlg.put("title", b.attributeValue("name", ""));
dlg.put("body", Map.of("type", "tpl",
"tpl", "表单页(pageid=" + b.attributeValue("pageid", "") + ")待 EDITFORM 模板转换"));
btn.put("dialog", dlg);
mappingNotes.add("button[insert] " + b.attributeValue("name") + " → dialog 占位(指向 pageid="
+ b.attributeValue("pageid", "") + ",需 EDITFORM 转换器)");
}
case "delete" -> {
btn.put("level", "danger");
btn.put("actionType", "ajax");
btn.put("confirmText", "确认删除选中记录?");
btn.put("api", "delete:/api/entity/" + table + "/${ids}");
mappingNotes.add("button[delete] → ajax DELETE /api/entity/" + table + "/${ids}(REST 端点待实现)");
}
default -> mappingNotes.add("button[" + btnType + "] " + b.attributeValue("name") + " → 普通按钮占位");
}
toolbar.add(btn);
}
toolbar.add("pagination");
// ── 组装 page > crud
Map<String, Object> crudSchema = new LinkedHashMap<>(); Map<String, Object> crudSchema = new LinkedHashMap<>();
crudSchema.put("type", "crud"); crudSchema.put("type", "crud");
crudSchema.put("api", "/api/entity/" + table + "/list?page=${page}&perPage=${perPage}"); crudSchema.put("api", listApi(crud, table));
crudSchema.put("syncLocation", false); crudSchema.put("syncLocation", false);
if (filter != null) { if (filter != null) {
crudSchema.put("filter", filter); crudSchema.put("filter", filter);
@@ -157,19 +125,428 @@ public class TemplateToAmisConverter {
crudSchema.put("headerToolbar", toolbar); crudSchema.put("headerToolbar", toolbar);
crudSchema.put("primaryField", table + "_ID"); crudSchema.put("primaryField", table + "_ID");
return page(title, crudSchema);
}
/** display/field → crud columns(含 _DISPLAY__ 翻译列、合计/金额特性)。 */
private List<Map<String, Object>> buildColumns(Element display, ConversionResult result) {
List<Map<String, Object>> columns = new ArrayList<>();
for (Element f : display.elements("field")) {
String name = f.attributeValue("name", "");
Map<String, Object> col = new LinkedHashMap<>();
if (name.endsWith("_DISPLAY__")) {
String raw = name.substring(0, name.length() - "_DISPLAY__".length());
col.put("name", raw);
result.note("display@field " + name + " → 原始列 " + raw + "(翻译列,REST 层待补显示值)");
} else {
col.put("name", name);
}
col.put("label", UiTypeMapper.firstNonBlank(f.attributeValue("text"), f.attributeValue("label"), name));
String width = f.attributeValue("width");
if (width != null && width.matches("\\d+")) {
col.put("width", Integer.parseInt(width));
}
// 金额列 → number 类型 + 千分位(报表迁移方案 A 类口径)
if ("true".equals(f.attributeValue("ismoney"))) {
col.put("type", "number");
col.put("precision", 2);
col.put("prefix", "");
result.note("display@field " + name + " ismoney=true → 列 type=number(precision=2,千分位)");
}
// 对齐
String align = f.attributeValue("horizontalalignment");
if ("2".equals(align)) {
col.put("className", "text-right");
} else if ("1".equals(align)) {
col.put("className", "text-center");
}
if ("true".equals(f.attributeValue("hidden"))) {
col.put("toggled", false);
result.note("display@field " + name + " hidden=true → columns-toggler 默认隐藏");
}
columns.add(col);
}
return columns;
}
/** search/field → filter 表单(uitype 映射经 UiTypeMapper 统一)。 */
private Map<String, Object> buildSearchFilter(Element search, ConversionResult result) {
if (search == null || search.elements("field").isEmpty()) {
return null;
}
List<Map<String, Object>> items = new ArrayList<>();
for (Element f : search.elements("field")) {
items.add(UiTypeMapper.mapField(f, result, "search"));
}
Map<String, Object> filter = new LinkedHashMap<>();
filter.put("title", "查询");
filter.put("body", items);
noteScript(search, "search", result);
return filter;
}
/** crud 的 button 可挂 crud 下,也可挂 display 下;统一收集。 */
private List<Element> collectButtons(Element crud) {
List<Element> buttons = new ArrayList<>(crud.elements("button"));
Element display = crud.element("display");
if (display != null) {
buttons.addAll(display.elements("button"));
}
return buttons;
}
private List<Object> buildToolbar(List<Element> buttons, String table, ConversionResult result) {
List<Object> toolbar = new ArrayList<>();
toolbar.add("bulkActions");
for (Element b : buttons) {
if ("false".equals(b.attributeValue("isshow"))) {
continue;
}
String btnType = b.attributeValue("type", "");
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("label", UiTypeMapper.firstNonBlank(b.attributeValue("name"), b.attributeValue("id"), btnType));
switch (btnType) {
case "insert" -> {
btn.put("level", "primary");
btn.put("actionType", "dialog");
Map<String, Object> dlg = new LinkedHashMap<>();
dlg.put("type", "dialog");
dlg.put("title", b.attributeValue("name", "新增"));
dlg.put("body", Map.of("type", "tpl",
"tpl", "表单页(pageid=" + b.attributeValue("pageid", "") + ")待 EDITFORM 模板联动"));
btn.put("dialog", dlg);
result.note("button[insert] " + b.attributeValue("name") + " → dialog 占位(指向 pageid="
+ b.attributeValue("pageid", "") + ",需 EDITFORM 转换器联动)");
}
case "delete" -> {
btn.put("level", "danger");
btn.put("actionType", "ajax");
btn.put("confirmText", UiTypeMapper.firstNonBlank(b.attributeValue("showmsg"), "确认删除选中记录?"));
btn.put("api", "delete:/api/entity/" + table + "/${ids}");
result.note("button[delete] → ajax DELETE /api/entity/" + table + "/${ids}(REST 端点待实现)");
}
case "update" -> {
btn.put("actionType", "dialog");
result.note("button[update] " + b.attributeValue("name") + " → 编辑 dialog 占位(需 EDITFORM 联动)");
}
default -> result.note("button[" + btnType + "] " + b.attributeValue("name") + " → 普通按钮占位");
}
toolbar.add(btn);
}
toolbar.add("pagination");
return toolbar;
}
private String listApi(Element crud, String table) {
Element display = crud.element("display");
String selectservice = crud.attributeValue("selectservice",
display != null ? display.attributeValue("selectservice") : null);
if (selectservice != null && !selectservice.isBlank()) {
return "/api/flow/" + selectservice + "?page=${page}&perPage=${perPage}";
}
return "/api/entity/" + table + "/list?page=${page}&perPage=${perPage}";
}
// ──────────────────────────────────────────────────────────────────────
// form(EDITFORM 表单页)—— 字段取自 pageid 指向的 view_page
// ──────────────────────────────────────────────────────────────────────
private Map<String, Object> convertForm(Element form, ConversionResult result,
Function<String, String> pageResolver) throws Exception {
String entityId = form.attributeValue("entityid", "");
String table = resolveTableName(entityId, result);
String pageId = form.attributeValue("pageid", "");
List<Map<String, Object>> formItems = new ArrayList<>();
String pageXml = (pageResolver != null && !pageId.isBlank()) ? pageResolver.apply(pageId) : null;
if (pageXml != null && !pageXml.isBlank()) {
Document pageDoc = DocumentHelper.parseText(pageXml);
Element fields = pageDoc.getRootElement().element("fields");
if (fields != null) {
for (Element f : fields.elements("field")) {
formItems.add(UiTypeMapper.mapField(f, result, "editform"));
}
result.note("form@pageid=" + pageId + " → 解析 view_page 取得 " + formItems.size() + " 字段");
}
// HTML <layout> 自定义表格版式无法直接平移到 amis flex,标注降级
if (pageDoc.getRootElement().element("layout") != null) {
result.degrade("form 含 HTML <layout> 自定义表格版式 → amis 默认纵向布局替代,版式需人工核对");
}
} else {
result.degrade("form@pageid=" + pageId + " 无法解析 view_page(缺解析器/页面不存在)→ 空表单壳");
}
// method → form actions
List<Object> actions = new ArrayList<>();
for (Element m : form.elements("method")) {
String mname = m.attributeValue("name");
if (mname == null) {
continue;
}
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("label", mname);
btn.put("actionType", "submit");
String svc = m.attributeValue("servicename", "");
if (!svc.isBlank()) {
result.note("form@method " + mname + "(servicename=" + svc + ") → submit → /api/flow/" + svc);
}
actions.add(btn);
}
noteFormScripts(form, result);
Map<String, Object> formSchema = new LinkedHashMap<>();
formSchema.put("type", "form");
formSchema.put("title", "");
formSchema.put("api", "/api/entity/" + table + "/save");
formSchema.put("body", formItems);
if (!actions.isEmpty()) {
formSchema.put("actions", actions);
}
return page("", formSchema);
}
// ──────────────────────────────────────────────────────────────────────
// tree(树 / 树+grid)
// ──────────────────────────────────────────────────────────────────────
private Map<String, Object> convertTree(Element tree, ConversionResult result) {
// type=4:树+grid 引用式(<treetemplate ref/> + <gridtemplate ref/>)
Element treeTemplate = tree.element("treetemplate");
Element gridTemplate = tree.element("gridtemplate");
if (treeTemplate != null || gridTemplate != null) {
return convertTreeGrid(tree, treeTemplate, gridTemplate, result);
}
// type=3:声明式树(含 <node entityid selectservice>)
Element node = tree.element("node");
Map<String, Object> treeSchema = new LinkedHashMap<>();
treeSchema.put("type", "input-tree");
treeSchema.put("name", "tree");
treeSchema.put("multiple", false);
if (node != null) {
String svc = node.attributeValue("selectservice", "");
if (!svc.isBlank()) {
treeSchema.put("source", "/api/flow/" + svc);
result.note("tree@node selectservice=" + svc + " → input-tree source /api/flow/" + svc);
}
String entityId = node.attributeValue("entityid", "");
if (!entityId.isBlank()) {
resolveTableName(entityId, result);
}
if (node.element("nextnodes") != null && !node.element("nextnodes").elements().isEmpty()) {
result.note("tree@node 含 nextnodes 多级 → amis input-tree 懒加载(deferApi 待补)");
}
// 树节点 buttons(增删改保存)无法直接平移到 input-tree,标注降级
if (node.element("buttons") != null && !node.element("buttons").elements().isEmpty()) {
result.degrade("tree@node 含 buttons(增删改保存) → input-tree 不原生支持节点级按钮,需自定义工具栏");
}
} else {
result.degrade("tree 无 <node> 声明 → 空树壳");
}
String rootName = tree.attributeValue("rootname");
return page(rootName != null ? rootName : "树", treeSchema);
}
private Map<String, Object> convertTreeGrid(Element tree, Element treeTemplate, Element gridTemplate,
ConversionResult result) {
Map<String, Object> treeSchema = new LinkedHashMap<>();
treeSchema.put("type", "input-tree");
treeSchema.put("name", "tree");
if (treeTemplate != null) {
String ref = treeTemplate.attributeValue("ref", "");
treeSchema.put("source", "/api/template/" + ref + "/tree");
result.degrade("tree+grid: treetemplate ref=" + ref + " → 跨模板引用,树数据源 /api/template 待联动");
}
Map<String, Object> gridSchema = new LinkedHashMap<>();
gridSchema.put("type", "crud");
if (gridTemplate != null) {
String ref = gridTemplate.attributeValue("ref", "");
String rcol = gridTemplate.attributeValue("rcolumnname", "");
gridSchema.put("api", "/api/template/" + ref + "/list?" + rcol + "=${tree}");
result.degrade("tree+grid: gridtemplate ref=" + ref + "(rcolumn=" + rcol
+ ") → 跨模板引用,右侧列表数据源待联动");
}
gridSchema.put("columns", new ArrayList<>());
Map<String, Object> hbox = new LinkedHashMap<>();
hbox.put("type", "flex");
hbox.put("items", List.of(
Map.of("md", 3, "body", treeSchema),
Map.of("md", 9, "body", gridSchema)));
return page("树+列表", hbox);
}
// ──────────────────────────────────────────────────────────────────────
// report(A 类表格式报表)—— 报表迁移方案口径
// ──────────────────────────────────────────────────────────────────────
private Map<String, Object> convertReport(Element report, ConversionResult result) {
String title = UiTypeMapper.firstNonBlank(report.attributeValue("title"),
attrOf(report.element("search"), "reporttitle"), "报表");
String entityId = report.attributeValue("entityid", "");
resolveTableName(entityId, result);
// display → columns(含 ismoney/issummer 合计列)
Element display = report.element("display");
List<Map<String, Object>> columns = display != null ? buildColumns(display, result) : new ArrayList<>();
// 合计列(issummer=true)→ crud footer 合计行 / 列 summary
List<String> sumCols = new ArrayList<>();
if (display != null) {
for (Element f : display.elements("field")) {
if ("true".equals(f.attributeValue("issummer"))) {
sumCols.add(f.attributeValue("name"));
}
}
}
// search → filter(报表查询参数),selectservice → api
Element search = report.element("search");
Map<String, Object> filter = buildSearchFilter(search, result);
String selectservice = attrOf(search, "selectservice");
Map<String, Object> crudSchema = new LinkedHashMap<>();
crudSchema.put("type", "crud");
if (selectservice != null && !selectservice.isBlank()) {
crudSchema.put("api", "/api/flow/" + selectservice + "?page=${page}&perPage=${perPage}");
result.note("report@search selectservice=" + selectservice + " → crud api /api/flow/" + selectservice
+ "(服务流 REST 化,报表迁移方案 D 节)");
} else {
crudSchema.put("api", "/api/report/" + entityId + "/list");
result.degrade("report 无 selectservice → 兜底 api /api/report,数据源待补");
}
crudSchema.put("syncLocation", false);
if (filter != null) {
crudSchema.put("filter", filter);
}
crudSchema.put("columns", columns);
if (!sumCols.isEmpty()) {
// amis crud footer 合计行:footerToolbar + 列上 summary 由后端返回,这里登记口径
Map<String, Object> affix = new LinkedHashMap<>();
affix.put("type", "static");
crudSchema.put("affixHeader", false);
crudSchema.put("footable", false);
result.note("report 合计列 issummer=true: " + String.join(",", sumCols)
+ " → crud 合计行(amis summaryFields,合计值由 /api/flow 返回 totals 字段)");
crudSchema.put("summaryFields", sumCols);
}
// 图表报表(ischart=true):本批不平移 ECharts option,标注降级(报表迁移方案 B 类,单列)
if ("true".equals(attrOf(search, "ischart"))) {
result.degrade("report ischart=true → 图表类报表(B 类),ECharts option 平移单列处置,本批转为表格降级");
}
// JOR 套打版式(reportfile CDATA 非空)→ 不迁移引擎(报表迁移方案 C 类)
Element reportfile = report.element("reportfile");
if (reportfile != null && !reportfile.getTextTrim().isBlank()) {
result.degrade("report 含 reportfile(JOR 套打版式 " + reportfile.getTextTrim().length()
+ " 字符) → C 类不迁移引擎,仅转表格视图(套打另案 univer/Web 打印)");
}
noteScripts(report, result);
return page(title, crudSchema);
}
// ──────────────────────────────────────────────────────────────────────
// group(分组容器)—— 子模板跨引用
// ──────────────────────────────────────────────────────────────────────
private Map<String, Object> convertGroup(Element group, ConversionResult result) {
List<Map<String, Object>> tabs = new ArrayList<>();
for (Element t : group.elements("template")) {
String tempId = t.attributeValue("tempid", "");
String name = t.attributeValue("name", tempId);
Map<String, Object> tab = new LinkedHashMap<>();
tab.put("title", name);
tab.put("body", Map.of("type", "tpl",
"tpl", "子模板(tempid=" + tempId + ")待跨模板联动加载"));
tabs.add(tab);
result.note("group@template " + name + "(tempid=" + tempId + ") → tab 占位(子模板跨引用)");
}
result.degrade("group 分组容器仅转 tabs 壳 → 各 tab 子模板需跨模板联动加载(本批不联动)");
Map<String, Object> tabsSchema = new LinkedHashMap<>();
tabsSchema.put("type", "tabs");
tabsSchema.put("tabs", tabs);
return page("分组", tabsSchema);
}
// ──────────────────────────────────────────────────────────────────────
// 公共工具
// ──────────────────────────────────────────────────────────────────────
private static Map<String, Object> page(String title, Object body) {
Map<String, Object> page = new LinkedHashMap<>(); Map<String, Object> page = new LinkedHashMap<>();
page.put("type", "page"); page.put("type", "page");
page.put("title", title); page.put("title", title);
page.put("body", crudSchema); page.put("body", body);
return page; return page;
} }
private String resolveTableName(String entityId) { private static String attrOf(Element el, String attr) {
return el == null ? null : el.attributeValue(attr);
}
/** dom4j 取脚本必须用 getText()(迁移手册 §5.3:getTextTrim 会压扁 Groovy 换行)。 */
private static void noteScript(Element el, String origin, ConversionResult result) {
String script = el.attributeValue("script");
if (script != null && !script.isBlank()) {
result.note(origin + "@script 存在(" + script.length() + " 字符) → 归入脚本分桶,本转换器跳过");
}
}
private static void noteScripts(Element parent, ConversionResult result) {
Element scripts = parent.element("scripts");
if (scripts != null) {
for (Element s : scripts.elements("script")) {
String body = s.getText();
if (body != null && !body.isBlank()) {
result.note("scripts@" + s.attributeValue("name", "?") + " 存在(" + body.length()
+ " 字符,getText 保留换行) → 脚本分桶处理");
}
}
}
}
private static void noteFormScripts(Element form, ConversionResult result) {
for (Element s : form.elements("script")) {
String body = s.getText();
if (body != null && !body.isBlank()) {
result.note("form@script " + s.attributeValue("name", "?") + " 存在(" + body.length()
+ " 字符,getText 保留换行) → 脚本分桶处理");
}
}
}
private static String safeMsg(Exception e) {
return e.getMessage() == null ? "" : e.getMessage();
}
/** entityid → 物理表名;解析失败(孤儿模板)登记台账并返回占位,不抛异常(迁移手册 §7.4)。 */
private String resolveTableName(String entityId, ConversionResult result) {
if (entityId == null || entityId.isBlank()) {
result.degrade("entityid 为空 → 无法解析实体表(孤儿模板候选)");
return "UNKNOWN_ENTITY";
}
try {
String table = jdbcTemplate.queryForObject(
"SELECT TABLENAME FROM SYS_ENTITY WHERE SYS_ENTITY_ID=?", String.class, entityId);
result.note("entityid=" + entityId + " → 实体表 " + table + "(经 SYS_ENTITY 解析)");
return table;
} catch (Exception e) {
result.degrade("entityid=" + entityId + " 在 SYS_ENTITY 无对应实体 → 孤儿模板(§7.4),表名占位");
return "ORPHAN_" + entityId.replaceAll("[^A-Za-z0-9_]", "_");
}
}
/** view_page.xml 解析器(form EDITFORM 用)。 */
private String loadPageXml(String pageId) {
try { try {
return jdbcTemplate.queryForObject( return jdbcTemplate.queryForObject(
"SELECT TABLENAME FROM SYS_ENTITY WHERE SYS_ENTITY_ID=?", String.class, entityId); "SELECT xml::text FROM VIEW_PAGE WHERE VIEW_PAGE_ID=? AND xml IS NOT NULL",
String.class, pageId);
} catch (Exception e) { } catch (Exception e) {
return "UNKNOWN_" + entityId; return null;
} }
} }
} }

View File

@@ -0,0 +1,196 @@
package com.eip4.platform.converter;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
/**
* 旧引擎 {@code <field uitype="...">} → amis 表单控件的统一映射。
*
* <p>被「查询过滤表单(search)」「表单页(EDITFORM / form 的 page.fields)」「报表查询参数(report.search)」
* 三处共享——映射规则唯一来源,避免三处各写一份漂移。客户库实测 uitype 全集(按出现频次):
* TextField / SelectDialog / ComboBox / DoublePopupDateField / NumberField /
* PopupDateField / MultiSelectDialog / CheckBox / TextArea。
*
* <p>每命中一处都通过 {@link ConversionResult#note} 登记映射台账;未知 uitype 走
* {@link ConversionResult#degrade} 降级为 input-text 并标注。
*/
final class UiTypeMapper {
private UiTypeMapper() {
}
/**
* 把一个 {@code <field>} 元素映射为一个 amis 表单项 Map。
*
* @param f 字段元素(含 name/label/uitype/comboboxid 等属性)
* @param result 转换结果(登记映射台账 / 降级标注)
* @param origin 来源标签("search" / "editform" / "report.search"),写进台账便于定位
* @return amis 表单项
*/
static Map<String, Object> mapField(Element f, ConversionResult result, String origin) {
String name = f.attributeValue("name", "");
String uitype = f.attributeValue("uitype", "TextField");
// label 优先用 label 属性,回退 text(display 段用 text)、再回退 name
String label = firstNonBlank(f.attributeValue("label"), f.attributeValue("text"), name);
Map<String, Object> item = new LinkedHashMap<>();
item.put("name", name);
item.put("label", label);
boolean required = "true".equals(f.attributeValue("required"));
if (required) {
item.put("required", true);
}
if ("true".equals(f.attributeValue("readonly"))) {
item.put("disabled", true);
}
if ("true".equals(f.attributeValue("hidden"))) {
item.put("hidden", true);
}
switch (uitype) {
case "TextField" -> {
item.put("type", "input-text");
applyLength(item, f);
}
case "TextArea" -> item.put("type", "textarea");
case "NumberField" -> {
item.put("type", "input-number");
String mdec = f.attributeValue("mdec");
if (mdec != null && !mdec.isBlank()) {
try {
item.put("precision", Integer.parseInt(mdec));
} catch (NumberFormatException ignore) {
// mdec 非数值 → 忽略精度,控件本身已成立
}
}
result.note(origin + "@field " + name + " uitype=NumberField → input-number(precision=" + mdec + ")");
}
case "CheckBox" -> {
item.put("type", "checkbox");
result.note(origin + "@field " + name + " uitype=CheckBox → checkbox");
}
case "EditGrid", "FormEditGrid" -> {
// 表单内嵌可编辑子表(主子表的子表侧)→ amis input-table;
// 子列取自 <editgridtemplate> CDATA 内 <component><editgrid><field>。
item.put("type", "input-table");
item.put("addable", !"false".equals(f.attributeValue("showaddbutton")));
item.put("removable", !"false".equals(f.attributeValue("showdeletebutton")));
item.put("columns", buildEditGridColumns(f, result, name));
result.degrade(origin + "@field " + name + " uitype=" + uitype
+ " → input-table 子表(主子表子表侧,列取自 editgridtemplate;保存联动 updateSubTable 待后端)");
}
case "ComboBox" -> {
item.put("type", "select");
item.put("clearable", true);
String dict = firstNonBlank(f.attributeValue("comboboxid"),
f.attributeValue("comboboxitemservice"), "");
if (!dict.isBlank()) {
item.put("source", "/api/poc/dict/" + dict);
result.note(origin + "@field " + name + " uitype=ComboBox(comboboxid=" + dict
+ ") → select + source 字典接口(接口待实现)");
} else {
result.note(origin + "@field " + name + " uitype=ComboBox(无字典源) → 空 select");
}
}
case "PopupDateField" -> {
String format = f.attributeValue("format", "");
boolean hasTime = format.contains("H") || format.contains("m");
item.put("type", hasTime ? "input-datetime" : "input-date");
result.note(origin + "@field " + name + " uitype=PopupDateField(format=" + format + ") → "
+ (hasTime ? "input-datetime" : "input-date"));
}
case "DoublePopupDateField" -> {
// 双日期 = 区间选择
String format = f.attributeValue("format", "");
boolean hasTime = format.contains("H") || format.contains("m");
item.put("type", hasTime ? "input-datetime-range" : "input-date-range");
result.note(origin + "@field " + name + " uitype=DoublePopupDateField → "
+ (hasTime ? "input-datetime-range" : "input-date-range") + "(区间)");
}
case "SelectDialog" -> {
// 旧引擎弹窗选择器 → amis select + 远程 source(弹窗数据由 dialogid 指向的模板提供,跨模板引用本批未联动)。
// 注:不用 amis picker——picker 需内嵌 pickerSchema(CRUD),且 6.13 schema 未把 picker 纳入
// 表单项 oneOf,闸一会拒(手册 §8.2 schema 严格性);select+source 双闸皆过,是更保真的降级。
item.put("type", "select");
item.put("clearable", true);
item.put("source", "/api/picker/" + f.attributeValue("dialogid", "") + "/list");
result.degrade(origin + "@field " + name + " uitype=SelectDialog(dialogid="
+ f.attributeValue("dialogid", "") + ") → select+source 占位(弹窗数据源 /api/picker,需后端实现)");
}
case "MultiSelectDialog" -> {
item.put("type", "select");
item.put("multiple", true);
item.put("clearable", true);
item.put("source", "/api/picker/" + f.attributeValue("dialogid", "") + "/list");
result.degrade(origin + "@field " + name + " uitype=MultiSelectDialog(dialogid="
+ f.attributeValue("dialogid", "") + ") → select(multiple)+source 占位(数据源待实现)");
}
default -> {
item.put("type", "input-text");
result.degrade(origin + "@field " + name + " uitype=" + uitype
+ " → 暂映射 input-text(映射表待补该控件)");
}
}
return item;
}
/** 解析 EditGrid 的 {@code <editgridtemplate>} CDATA,把内嵌 editgrid 字段转成 input-table 列。 */
private static List<Map<String, Object>> buildEditGridColumns(Element f, ConversionResult result, String name) {
List<Map<String, Object>> columns = new ArrayList<>();
Element tpl = f.element("editgridtemplate");
String tplXml = tpl != null ? tpl.getText() : null;
if (tplXml == null || tplXml.isBlank()) {
result.note("editgrid " + name + " 无 editgridtemplate → 空子表列");
return columns;
}
try {
Document doc = DocumentHelper.parseText(tplXml.trim());
Element editgrid = doc.getRootElement().element("editgrid");
if (editgrid == null) {
return columns;
}
for (Element sub : editgrid.elements("field")) {
if ("true".equals(sub.attributeValue("hidden"))) {
continue;
}
// 子列复用同一套 uitype 映射,但落到 quickEdit 语义;这里取最小可渲染列
Map<String, Object> col = new LinkedHashMap<>();
col.put("name", sub.attributeValue("name", ""));
col.put("label", firstNonBlank(sub.attributeValue("label"), sub.attributeValue("name")));
col.put("type", "input-text"); // 子表列统一可编辑文本;精细控件由 quickEdit 后续细化
columns.add(col);
}
result.note("editgrid " + name + " → input-table " + columns.size() + " 列(取自 editgridtemplate)");
} catch (Exception e) {
result.note("editgrid " + name + " editgridtemplate 解析失败: " + e.getClass().getSimpleName());
}
return columns;
}
private static void applyLength(Map<String, Object> item, Element f) {
String max = f.attributeValue("maxlength");
if (max != null && !max.isBlank()) {
try {
item.put("maxLength", Integer.parseInt(max));
} catch (NumberFormatException ignore) {
// 忽略非数值长度约束
}
}
}
static String firstNonBlank(String... candidates) {
for (String c : candidates) {
if (c != null && !c.isBlank()) {
return c;
}
}
return "";
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,72 @@
package com.eip4.platform.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;
/**
* 闸一 {@link SchemaGate} 宽松语义校验 + CLI 辅助逻辑(URL 守门 / 原因归类)单测。
*/
class SchemaGateAndCliTest {
@Test
void schemaGate_转换后的crud过闸() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
lenient().when(jdbc.queryForObject(any(String.class), eq(String.class), any(Object[].class)))
.thenReturn("PM_DEMO");
TemplateToAmisConverter converter = new TemplateToAmisConverter(jdbc);
String xml = "<crud title='角色维护' entityid='e1'><display selectservice='SVC'>"
+ "<field name='NAME' text='名称' width='100'/></display>"
+ "<search><field name='NAME' label='名称' uitype='TextField'/></search></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), id -> null);
SchemaGate gate = new SchemaGate();
List<String> errors = gate.validate(r.getSchema());
assertTrue(errors.isEmpty(), () -> "闸一应通过,但有错误: " + errors);
}
@Test
void schemaGate_明显非法schema被拒() {
SchemaGate gate = new SchemaGate();
// page.type 必须是字符串"page",这里给个数组型 body 顶层缺 type → 至少应报错
Map<String, Object> bad = Map.of("type", 12345);
List<String> errors = gate.validate(bad);
assertTrue(!errors.isEmpty(), "数值 type 应被 schema 拒绝");
}
@Test
void guardUrl_拒绝ceshi库() {
IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
() -> BatchConvertCli.guardUrl("jdbc:postgresql://192.168.20.68:5435/ceshi?currentSchema=eip3"));
assertTrue(ex.getMessage().contains("ceshi"));
}
@Test
void guardUrl_允许postgres库() {
BatchConvertCli.guardUrl("jdbc:postgresql://192.168.20.68:5435/postgres?currentSchema=eip3");
}
@Test
void bucket_原因归类三桶() {
assertEquals("孤儿模板", BatchConvertCli.bucket("entityid=x 在 SYS_ENTITY 无对应实体 → 孤儿模板"));
assertEquals("模板数据问题", BatchConvertCli.bucket("XML 解析失败: DocumentException"));
assertEquals("转换器缺陷", BatchConvertCli.bucket("uitype=SelectDialog → picker 占位"));
}
@Test
void classifyReasons_无降级为空() {
ConversionResult r = new ConversionResult("crud", new ArrayList<>());
assertEquals("", BatchConvertCli.classifyReasons(r));
}
}

View File

@@ -0,0 +1,308 @@
package com.eip4.platform.converter;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.jdbc.core.JdbcTemplate;
/**
* 各段转换规则单测(P4 转换器扩展)。JdbcTemplate 用 Mockito 桩,离线运行——
* SYS_ENTITY 解析返回固定表名,孤儿场景抛异常验证旁路。
*/
class TemplateToAmisConverterTest {
private TemplateToAmisConverter converter;
private Function<String, String> noPage;
@BeforeEach
void setUp() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
// 默认实体解析成功
lenient().when(jdbc.queryForObject(any(String.class), eq(String.class), any(Object[].class)))
.thenReturn("PM_DEMO");
converter = new TemplateToAmisConverter(jdbc);
noPage = pageId -> null;
}
@SuppressWarnings("unchecked")
private static Map<String, Object> body(Map<String, Object> page) {
return (Map<String, Object>) page.get("body");
}
// ── crud ────────────────────────────────────────────────────────────
@Test
void crud_display字段转列_含金额与隐藏() {
String xml = "<crud title='登录历史' entityid='e1'>"
+ "<display selectservice='SYS_LOGIN_SEARCH'>"
+ "<field name='SYS_X_ID' text='主键' width='200' hidden='true' iskeycolumn='true'/>"
+ "<field name='AMT' text='金额' width='150' ismoney='true' horizontalalignment='2'/>"
+ "</display></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals("crud", r.getRootElement());
assertEquals(ConversionGrade.SUCCESS, r.getGrade());
Map<String, Object> crud = body(r.getSchema());
List<Map<String, Object>> cols = (List<Map<String, Object>>) crud.get("columns");
assertEquals(2, cols.size());
assertEquals(false, cols.get(0).get("toggled")); // 隐藏列默认折叠
assertEquals("number", cols.get(1).get("type")); // 金额列 number
assertEquals("text-right", cols.get(1).get("className"));
// selectservice → api 走 /api/flow
assertTrue(((String) crud.get("api")).startsWith("/api/flow/SYS_LOGIN_SEARCH"));
}
@Test
void crud_search字段映射各类uitype() {
String xml = "<crud entityid='e1'><display/>"
+ "<search>"
+ "<field name='A' label='文本' uitype='TextField' maxlength='50'/>"
+ "<field name='B' label='字典' uitype='ComboBox' comboboxid='WFSTATUS'/>"
+ "<field name='C' label='日期' uitype='PopupDateField' format='yyyy-MM-dd'/>"
+ "<field name='D' label='区间' uitype='DoublePopupDateField' format='yyyy-MM-dd HH:mm'/>"
+ "<field name='E' label='数值' uitype='NumberField' mdec='2'/>"
+ "</search></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
Map<String, Object> filter = (Map<String, Object>) crud.get("filter");
List<Map<String, Object>> items = (List<Map<String, Object>>) filter.get("body");
assertEquals("input-text", items.get(0).get("type"));
assertEquals(50, items.get(0).get("maxLength"));
assertEquals("select", items.get(1).get("type"));
assertEquals("/api/poc/dict/WFSTATUS", items.get(1).get("source"));
assertEquals("input-date", items.get(2).get("type"));
assertEquals("input-datetime-range", items.get(3).get("type")); // 含时分 → datetime-range
assertEquals("input-number", items.get(4).get("type"));
assertEquals(2, items.get(4).get("precision"));
}
@Test
void crud_selectDialog降级为select() {
String xml = "<crud entityid='e1'><display/>"
+ "<search><field name='PROJ' label='工程' uitype='SelectDialog' dialogid='d1'/></search></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals(ConversionGrade.PARTIAL, r.getGrade()); // 数据源未联动 → 降级
Map<String, Object> crud = body(r.getSchema());
Map<String, Object> filter = (Map<String, Object>) crud.get("filter");
List<Map<String, Object>> items = (List<Map<String, Object>>) filter.get("body");
// SelectDialog → select+source(picker 会被闸一拒,见 §8.2)
assertEquals("select", items.get(0).get("type"));
assertEquals("/api/picker/d1/list", items.get(0).get("source"));
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("SelectDialog")));
}
@Test
void crud_button删除转ajax() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='delete' name='删除' isshow='true' showmsg='确认删除?'>"
+ "<method servicename='X_DELETE'/></button></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
Map<String, Object> btn = (Map<String, Object>) toolbar.get(1);
assertEquals("ajax", btn.get("actionType"));
assertEquals("确认删除?", btn.get("confirmText"));
assertTrue(((String) btn.get("api")).startsWith("delete:/api/entity/"));
}
@Test
void crud_isshowFalse按钮跳过() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='delete' name='删除' isshow='false'/></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
// bulkActions + pagination,无删除按钮
assertEquals(2, toolbar.size());
}
// ── form (EDITFORM) ──────────────────────────────────────────────────
@Test
void form_从page解析字段() {
String pageXml = "<page entityid='e9'><fields>"
+ "<field name='NAME' label='名称' uitype='TextField' required='true'/>"
+ "<field name='STATUS' label='状态' uitype='ComboBox' comboboxid='YESNO'/>"
+ "</fields></page>";
Function<String, String> resolver = id -> "p1".equals(id) ? pageXml : null;
String xml = "<form entityid='e1' pageid='p1'>"
+ "<method id='m1' name='保存' servicename='X_ADD'/></form>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), resolver);
assertEquals("form", r.getRootElement());
Map<String, Object> form = body(r.getSchema());
assertEquals("form", form.get("type"));
List<Map<String, Object>> items = (List<Map<String, Object>>) form.get("body");
assertEquals(2, items.size());
assertEquals(true, items.get(0).get("required"));
assertEquals("select", items.get(1).get("type"));
List<Object> actions = (List<Object>) form.get("actions");
assertEquals(1, actions.size());
}
@Test
void form_editGrid转inputTable子表() {
String pageXml = "<page entityid='e9'><fields>"
+ "<field name='NAME' label='名称' uitype='TextField'/>"
+ "<field name='PAIDS' label='付款记录' uitype='EditGrid' showaddbutton='true' showdeletebutton='false'>"
+ "<editgridtemplate><![CDATA[<component><editgrid entityid='c1'>"
+ "<field name='SUB_ID' label='主键' uitype='TextField' hidden='true'/>"
+ "<field name='MONEY' label='金额' uitype='NumberField'/>"
+ "</editgrid></component>]]></editgridtemplate>"
+ "</field></fields></page>";
Function<String, String> resolver = id -> pageXml;
String xml = "<form entityid='e1' pageid='p1'/>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), resolver);
Map<String, Object> form = body(r.getSchema());
List<Map<String, Object>> items = (List<Map<String, Object>>) form.get("body");
Map<String, Object> sub = items.get(1);
assertEquals("input-table", sub.get("type"));
assertEquals(true, sub.get("addable"));
assertEquals(false, sub.get("removable"));
List<Map<String, Object>> cols = (List<Map<String, Object>>) sub.get("columns");
assertEquals(1, cols.size()); // 隐藏主键列被过滤
assertEquals("MONEY", cols.get(0).get("name"));
}
@Test
void form_缺页面解析器降级() {
String xml = "<form entityid='e1' pageid='p1'><load><method/></load></form>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals(ConversionGrade.PARTIAL, r.getGrade());
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("view_page")));
}
// ── tree ─────────────────────────────────────────────────────────────
@Test
void tree_声明式树转inputTree() {
String xml = "<tree isshowroot='true' rootname='区间'>"
+ "<node entityid='e1' selectservice='X_SEARCH' isroot='true'>"
+ "<buttons><button name='添加' type='insert'/></buttons>"
+ "<nextnodes/></node></tree>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals("tree", r.getRootElement());
Map<String, Object> tree = body(r.getSchema());
assertEquals("input-tree", tree.get("type"));
assertEquals("/api/flow/X_SEARCH", tree.get("source"));
assertEquals(ConversionGrade.PARTIAL, r.getGrade()); // 节点按钮 → 降级
}
@Test
void tree_treeGrid引用式() {
String xml = "<tree>"
+ "<treetemplate ref='t1' entityid='e1'/>"
+ "<gridtemplate ref='g1' entityid='e2' rcolumnname='EVENTID'/></tree>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
Map<String, Object> root = body(r.getSchema());
assertEquals("flex", root.get("type"));
assertEquals(ConversionGrade.PARTIAL, r.getGrade()); // 跨模板引用 → 降级
}
// ── report (A 类) ────────────────────────────────────────────────────
@Test
void report_合计列与selectservice() {
String xml = "<report title='安全费用' entityid='e1'>"
+ "<display>"
+ "<field name='X_ID' text='主键' width='200' hidden='true'/>"
+ "<field name='AMT' text='金额' width='150' ismoney='true' issummer='true' horizontalalignment='2'/>"
+ "</display>"
+ "<search selectservice='PM_SAFE_SEARCH' reporttitle='安全费用明细'>"
+ "<field name='YEAR' label='年份' uitype='NumberField' mdec='0'/></search>"
+ "<reportfile></reportfile><scripts/></report>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals("report", r.getRootElement());
Map<String, Object> crud = body(r.getSchema());
assertEquals("crud", crud.get("type"));
assertTrue(((String) crud.get("api")).startsWith("/api/flow/PM_SAFE_SEARCH"));
List<String> sum = (List<String>) crud.get("summaryFields");
assertEquals(List.of("AMT"), sum);
assertEquals("安全费用", r.getSchema().get("title"));
}
@Test
void report_jor套打版式降级() {
String xml = "<report title='套打' entityid='e1'>"
+ "<display><field name='A' text='A'/></display>"
+ "<search selectservice='S'/>"
+ "<reportfile><![CDATA[<jatools>非空版式定义内容占位非空版式</jatools>]]></reportfile></report>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals(ConversionGrade.PARTIAL, r.getGrade());
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("JOR")));
}
@Test
void report_图表降级() {
String xml = "<report title='图表' entityid='e1'>"
+ "<display><field name='A' text='A'/></display>"
+ "<search ischart='true' selectservice='S'/></report>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals(ConversionGrade.PARTIAL, r.getGrade());
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("ischart") || d.contains("图表")));
}
// ── group ────────────────────────────────────────────────────────────
@Test
void group_转tabs占位() {
String xml = "<group>"
+ "<template tempid='t1' name='已发消息'/>"
+ "<template tempid='t2' name='已收消息' defaultshow='true'/></group>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
assertEquals("group", r.getRootElement());
Map<String, Object> tabs = body(r.getSchema());
assertEquals("tabs", tabs.get("type"));
assertEquals(2, ((List<?>) tabs.get("tabs")).size());
assertEquals(ConversionGrade.PARTIAL, r.getGrade());
}
// ── 旁路与异常 ────────────────────────────────────────────────────────
@Test
void 孤儿模板_entityid解析失败不抛异常() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
when(jdbc.queryForObject(any(String.class), eq(String.class), any(Object[].class)))
.thenThrow(new RuntimeException("no such entity"));
TemplateToAmisConverter c = new TemplateToAmisConverter(jdbc);
String xml = "<crud entityid='!!!bad'><display>"
+ "<field name='A' text='A'/></display></crud>";
ConversionResult r = c.convertGraded(xml, new ArrayList<>(), noPage);
assertNotNull(r.getSchema()); // 不抛异常,仍出 schema
assertEquals(ConversionGrade.PARTIAL, r.getGrade()); // 孤儿 → 降级
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("孤儿")));
}
@Test
void 解析失败xml_标记FAILED() {
ConversionResult r = converter.convertGraded("<crud><unclosed></crud>", new ArrayList<>(), noPage);
assertEquals(ConversionGrade.FAILED, r.getGrade());
assertNull(r.getSchema());
}
@Test
void 不支持根元素_标记FAILED() {
ConversionResult r = converter.convertGraded("<unknown/>", new ArrayList<>(), noPage);
assertEquals(ConversionGrade.FAILED, r.getGrade());
assertTrue(r.getDegrades().stream().anyMatch(d -> d.contains("不支持的根元素")));
}
@Test
void 兼容入口convert_失败抛异常() {
assertFalse(converter.convertGraded("<unknown/>", new ArrayList<>(), noPage).getGrade()
== ConversionGrade.SUCCESS);
}
}

View File

@@ -0,0 +1,3 @@
# 逐模板 schema JSON 是 CLI 可一键复跑的产物(6.8M/1489 文件),不入库,避免仓库膨胀。
# 保留分级清单.csv + 闸二结果.json 作为可审阅交付物。
schema/

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,183 @@
{
"perType": {
"crud": {
"sampled": 5,
"pass": 5,
"fail": 0
},
"tree": {
"sampled": 5,
"pass": 5,
"fail": 0
},
"group": {
"sampled": 5,
"pass": 5,
"fail": 0
},
"form": {
"sampled": 5,
"pass": 5,
"fail": 0
},
"report": {
"sampled": 5,
"pass": 5,
"fail": 0
}
},
"samples": [
{
"root": "crud",
"id": "00551ef5-1c76-4015-bec9-2e1c8b631deb",
"pass": true,
"reason": ""
},
{
"root": "crud",
"id": "009c4f52-636a-4688-8148-75cabe83fd83",
"pass": true,
"reason": ""
},
{
"root": "crud",
"id": "00e7a83b-dd1f-4d7a-a574-bc362bc785d2",
"pass": true,
"reason": ""
},
{
"root": "crud",
"id": "00f6638e-72c7-4834-96ff-904935375951",
"pass": true,
"reason": ""
},
{
"root": "crud",
"id": "01711eee-5b37-4801-895c-90195b06cc51",
"pass": true,
"reason": ""
},
{
"root": "tree",
"id": "0211a0e2-2073-4b24-b59f-e6757e5dcff0",
"pass": true,
"reason": ""
},
{
"root": "tree",
"id": "0246d4bd-232b-465d-9265-8c1fc1ecbdf2",
"pass": true,
"reason": ""
},
{
"root": "tree",
"id": "082f27b4-7ae9-4b21-acc9-2b2a6f7d9797",
"pass": true,
"reason": ""
},
{
"root": "tree",
"id": "09f5fb86-5ea4-46e4-91c4-26115216129c",
"pass": true,
"reason": ""
},
{
"root": "tree",
"id": "13accf09-82c7-44f7-9ad0-c0bbcc55cb09",
"pass": true,
"reason": ""
},
{
"root": "group",
"id": "05226af5-5c77-470f-b039-d894fc55714d",
"pass": true,
"reason": ""
},
{
"root": "group",
"id": "08158341-1b41-48be-9226-90a206960e8f",
"pass": true,
"reason": ""
},
{
"root": "group",
"id": "1d9e666d-8923-4d9a-8644-05ba3fa533aa",
"pass": true,
"reason": ""
},
{
"root": "group",
"id": "27e3d27b-8d0a-4f7d-b159-8713f8184aa7",
"pass": true,
"reason": ""
},
{
"root": "group",
"id": "286c8dc9-bebe-4d58-a1ae-b7f0f54654be",
"pass": true,
"reason": ""
},
{
"root": "form",
"id": "00511ac1-ee64-4ecd-a550-22842ee5be72",
"pass": true,
"reason": ""
},
{
"root": "form",
"id": "00a64619-0014-412f-8ca9-95edcf988c2f",
"pass": true,
"reason": ""
},
{
"root": "form",
"id": "0267be11-591a-4533-b7cc-079cef81086e",
"pass": true,
"reason": ""
},
{
"root": "form",
"id": "04da8989-3627-4360-9834-bb55178546dd",
"pass": true,
"reason": ""
},
{
"root": "form",
"id": "093627bf-d7e2-460b-b00c-5a49fb9ac671",
"pass": true,
"reason": ""
},
{
"root": "report",
"id": "00654052-f899-45d6-bbd4-04457c13025a",
"pass": true,
"reason": ""
},
{
"root": "report",
"id": "03ec5566-7d99-4eba-85ce-31e25f5e48ab",
"pass": true,
"reason": ""
},
{
"root": "report",
"id": "063fdf2a-3032-4220-9974-32f0a5932aa6",
"pass": true,
"reason": ""
},
{
"root": "report",
"id": "069325dd-9ede-4dbe-9149-c02a5992b951",
"pass": true,
"reason": ""
},
{
"root": "report",
"id": "072192b6-8737-4af2-a8e6-402343152e3a",
"pass": true,
"reason": ""
}
],
"generatedAt": "2026-06-11T08:22:09.035Z",
"perTypeTarget": 5
}

View File

@@ -4,7 +4,6 @@ import java.util.ArrayList;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.JdbcTemplate;
@@ -12,26 +11,24 @@ import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController; import org.springframework.web.bind.annotation.RestController;
import com.eip4.platform.converter.SchemaGate;
import com.eip4.platform.converter.TemplateToAmisConverter; import com.eip4.platform.converter.TemplateToAmisConverter;
import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.networknt.schema.JsonSchema;
import com.networknt.schema.JsonSchemaFactory;
import com.networknt.schema.SpecVersion;
import com.networknt.schema.ValidationMessage;
/** /**
* WS2:模板 XML → amis schema 转换 + 官方 schema.json(draft-07)机器校验闭环。 * WS2:模板 XML → amis schema 转换 + 官方 schema.json(draft-07)机器校验闭环。
* /api/poc/amis-schema 返回转换后的页面 schema(amis SDK 直接渲染) * /api/poc/amis-schema 返回转换后的页面 schema(amis SDK 直接渲染)
* /api/poc/amis-validate 转换 + 经 amis-schema-6.13.0.json 校验,返回映射台账与校验结果 * /api/poc/amis-validate 转换 + 经 amis-schema-6.13.0.json 校验,返回映射台账与校验结果
*
* <p>闸一校验(宽松语义预处理)已抽到 platform-converter 的 {@link SchemaGate},本类与 P4 批量 CLI
* 共享同一份口径(手册 §8.1「所有 ajv 校验处都需此预处理」)。
*/ */
@RestController @RestController
public class AmisSchemaController { public class AmisSchemaController {
private final TemplateToAmisConverter converter; private final TemplateToAmisConverter converter;
private final JdbcTemplate jdbcTemplate; private final JdbcTemplate jdbcTemplate;
private final ObjectMapper mapper = new ObjectMapper(); private final SchemaGate schemaGate = new SchemaGate();
private volatile JsonSchema amisSchema;
public AmisSchemaController(TemplateToAmisConverter converter, JdbcTemplate jdbcTemplate) { public AmisSchemaController(TemplateToAmisConverter converter, JdbcTemplate jdbcTemplate) {
this.converter = converter; this.converter = converter;
@@ -48,14 +45,12 @@ public class AmisSchemaController {
List<String> notes = new ArrayList<>(); List<String> notes = new ArrayList<>();
Map<String, Object> schema = converter.convert(loadXml(template), notes); Map<String, Object> schema = converter.convert(loadXml(template), notes);
JsonNode node = mapper.valueToTree(schema); List<String> errors = schemaGate.validate(schema);
Set<ValidationMessage> errors = officialSchema().validate(node);
Map<String, Object> resp = new LinkedHashMap<>(); Map<String, Object> resp = new LinkedHashMap<>();
resp.put("template", template); resp.put("template", template);
resp.put("schemaValid", errors.isEmpty()); resp.put("schemaValid", errors.isEmpty());
resp.put("validationErrors", errors.stream() resp.put("validationErrors", errors.stream().limit(20).collect(Collectors.toList()));
.map(ValidationMessage::getMessage).limit(20).collect(Collectors.toList()));
resp.put("mappingNotes", notes); resp.put("mappingNotes", notes);
resp.put("schema", schema); resp.put("schema", schema);
return resp; return resp;
@@ -64,11 +59,10 @@ public class AmisSchemaController {
/** 校验任意 amis 页面 schema(WS5:AI 生成的 schema 走这里过闸)。 */ /** 校验任意 amis 页面 schema(WS5:AI 生成的 schema 走这里过闸)。 */
@org.springframework.web.bind.annotation.PostMapping("/api/poc/validate-schema") @org.springframework.web.bind.annotation.PostMapping("/api/poc/validate-schema")
public Map<String, Object> validateSchema(@org.springframework.web.bind.annotation.RequestBody JsonNode schema) throws Exception { public Map<String, Object> validateSchema(@org.springframework.web.bind.annotation.RequestBody JsonNode schema) throws Exception {
Set<ValidationMessage> errors = officialSchema().validate(schema); List<String> errors = schemaGate.validate(schema);
Map<String, Object> resp = new LinkedHashMap<>(); Map<String, Object> resp = new LinkedHashMap<>();
resp.put("schemaValid", errors.isEmpty()); resp.put("schemaValid", errors.isEmpty());
resp.put("validationErrors", errors.stream() resp.put("validationErrors", errors.stream().limit(20).collect(Collectors.toList()));
.map(ValidationMessage::getMessage).limit(20).collect(Collectors.toList()));
return resp; return resp;
} }
@@ -78,36 +72,4 @@ public class AmisSchemaController {
String.class, template) String.class, template)
.get(0); .get(0);
} }
private JsonSchema officialSchema() throws Exception {
if (amisSchema == null) {
synchronized (this) {
if (amisSchema == null) {
JsonNode schemaNode = mapper.readTree(
getClass().getResourceAsStream("/amis-schema-6.13.0.json"));
// amis 官方 schema 大量使用 {"$ref":..., "additionalProperties":true} 的
// 兄弟键覆盖写法——这是 VSCode/Monaco 的宽松合并语义;严格 draft-07 下
// 兄弟键被忽略,被引用定义里的 additionalProperties:false 会拒绝一切输入。
// 预处理:全局剥除 additionalProperties:false,保留类型/必填/结构校验。
// 边界:未知渲染器类型无法被识别(schema 含 Loose 宽松分支,属设计内)。
stripStrictAdditionalProperties(schemaNode);
amisSchema = JsonSchemaFactory.getInstance(SpecVersion.VersionFlag.V7)
.getSchema(schemaNode);
}
}
}
return amisSchema;
}
private static void stripStrictAdditionalProperties(JsonNode node) {
if (node instanceof com.fasterxml.jackson.databind.node.ObjectNode obj) {
JsonNode ap = obj.get("additionalProperties");
if (ap != null && ap.isBoolean() && !ap.asBoolean()) {
obj.remove("additionalProperties");
}
obj.properties().forEach(e -> stripStrictAdditionalProperties(e.getValue()));
} else if (node instanceof com.fasterxml.jackson.databind.node.ArrayNode arr) {
arr.forEach(AmisSchemaController::stripStrictAdditionalProperties);
}
}
} }