Compare commits

...

6 Commits

Author SHA1 Message Date
fb8a37ddc5 fix(flow): 搜索时间段过滤——amis date-range 串转 DateTime[] 接通引擎区间查询
Some checks failed
ci / build-test-parity (push) Has been cancelled
操作日志等"时间段查不动"(设了起止仍返回全部)根因:amis input-date(time)-range
把时间段提交为 "起,止" 逗号串,但引擎 GeneralPO 的搜索 where 构建只对 DateTime[]
值生成区间条件 (col>=起 AND col<=止)——收到 String 识别不了,整条时间段过滤被忽略。
且保真层的 coerceByFlowId 只在写流(NAMED_WRITE)调用,读流(SEARCH)根本不 coerce。

修:
- FlowInputCoercer.coerceValue DATE/TIME 支持区间:含逗号 → 拆两段各 parse → DateTime[]
  (空段→null,引擎该侧不加约束);解析失败保留原值(fail-safe)。
- coerceDate 增 10-11 位 unix 秒识别(amis input-date(time)-range 默认 format=X 提交秒),
  原仅认 13 位毫秒;ISO/yyyy-MM-dd[ HH:mm:ss] 等格式不变。
- 新增 coerceSearchDatesByFlowId / coerceSearchDatesByTable:只转 DATE/TIME 列
  (其它过滤参一概不动 → 对已工作的文本/枚举/picker 搜索零回归)。
- FlowController 在 NAMED_READ / SYNTHESIZED(读流)路径调用上述方法。

注:单值日期 → DateTime(引擎 = 精确匹配,忠实老引擎);区间才是常见用法。

live 实证 SYS_DATA_LOG_SEARCH:无过滤 748179,远古区间 45643,2026-06 区间 535,
2026-06-15~18 格式化 53——不同区间返回不同结果(秒/毫秒/格式化字符串均识别)。
FlowInputCoercerTest 43 绿(+6 日期/区间用例)。已重建 platform-app + 重启 8093。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 17:57:46 +08:00
3276774037 fix(converter): 树编辑表单按 <layout> 槽位排版+隐藏未布局字段
type=3 可编辑树 master-detail(buildEditableTreeMasterDetail)原直接
form.put("body", formItems) 把 view_page <fields> 全平铺为可见输入框,
无视 <layout>——泄露 VERSION/主键/引用 id 等隐藏字段(标签还是裸列名),
且字段不按布局顺序。

老引擎 FormPageTemplateComponent 用 Vaadin CustomLayout:只渲染 <layout>
里有 <div location="X"> 槽位的字段(按文档序),无槽位字段绑进 FieldGroup
供提交但不显示。EDITFORM(convertForm)早已走 buildFormBody 复刻此行为,
唯独树编辑路径漏了。

改:buildEditableTreeMasterDetail 解析 pageRoot 后同样走 buildFormBody
(tabs + <div location> 文档序归位 + 未布局字段 hidden=true 收尾,提交不丢)。
影响 41 个可编辑树页(含功能模板下载/菜单维护/实体分类等)。

live 实证 13accf09:可见仅 ISOPEN/BUTTONCAPTION/DOCUMENT(布局序+正确标签),
VERSION/SYS_MENU_ID/VIEW_TEMPLATE_DOWNLAD_ID/VIEW_TEMPLATEID 隐藏。
全量重转 dry-run 深度 diff=41 页变(余保真),已重导收敛 0 diff。
converter 156 测试绿(树 master-detail 测试改递归取字段穿透布局容器)。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 17:37:55 +08:00
b5fe995344 feat(converter): 机制①整页改写器 + 功能模板下载门控(去添加按钮/改标题)
EngineclassDelta 原仅支持「crud 工具栏追加按钮」。新增 MUTATORS 注册表
(engineclass FQN → 整页 schema 改写器),apply 拆为 applyToolbarButtons
(crud 加按钮,行为不变)+ applyMutators(任意 body 整页改写),覆盖非
crud 加按钮类 delta。

注册 FuncDownloadComponent(功能模板下载模板管理 0246d4bd / 设置 13accf09,
type=3 树页 grid → 左 input-tree + 右 button-toolbar[添加] + form):复刻
refreshRightLayout —— ① 移除右表单「添加/删除」按钮(附件随菜单/实体生成
不应手工增删,老 cl.removeComponent(insert)/(del)),空 toolbar 整条移除;
② 右表单标题改「编辑模板附件」(老 panel.setCaption)。改写器重建列表回填,
兼容转换器的不可变 List.of 列 body(原地 removeIf 会 UOE)。

未做:老「仅 VIEW_TEMPLATEID 非空才显示右表单」门控——amis form visibleOn
依赖自身 initApi 数据成循环,正解需树节点携带该列(改 TemplateTreeController),
价值低暂延后。

另核对:实体分类-枚举组(b114351f) 老 EntityEnumerateType 用 UUID 当树节点 id
(Vaadin 懒加载防重复 addItem),EIP4 树端点用 PK 唯一 + 跨级去重 + 一次性全量
建树,结构上天然规避,实测 598 节点零重复 → 已覆盖,无需移植。

全量重转 dry-run 深度 diff 确认语义仅 2 页变(余 2725 页保真),已重导上线
(live 实证 13accf09 无「添加」按钮 + 标题「编辑模板附件」)。converter 156 测试绿。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 16:57:44 +08:00
17c449cbf5 feat(converter): 机制①定制视图 delta 注入 + filterscript 级联过滤
机制①(engineclass Java delta 移植):老系统「定制视图」=数据驱动 XML 由
默认模板引擎渲染,但配 engineclass 的视图有 Java 子类在默认引擎之上加/改
按钮。转换器已复刻默认页但抓不到 Java delta——新增 EngineclassDelta 注册表
(engineclass FQN → 工具栏按钮 builder),convertGraded 增 engineclass 入参,
默认页转好后追加注入(默认页不变,仅 append);BatchConvertCli 透传
view_template.engineclass。

本轮注册 4 个 framework 定制视图:
- UserManageView:设置主岗位 + 查看用户菜单
- SystemLogMainView:按类型删除 + 全部删除
- SysUserLoginHistoryMainView:按查询条件删除记录
- SysUserLoginInfoMainView:查看登录记录(下钻登录历史)

配套后端:
- LogController(/api/admin/log/delete-all|delete-by-type|delete-by-logintime)
  接 SystemLogManager;deleteByType 用 LogType 枚举白名单防注入。
- MenuController 新增 /api/admin/user/{userId}/menu(查看指定用户可见菜单树,
  移植 UserRoleView,与 /api/admin/menu 共用 menuTreeFor 构建逻辑)。

filterscript 级联(P1):view_page 字段 filterscript 的「按其它字段值过滤本
字段」语义无法统一脚本引擎,故按性能优先做模式匹配——动态/常量等值绑定追加
到 select source(&COL=${TRIG}),含 SQL/服务调用/控制流/WhereClause 的复杂
脚本整条跳过(不误改);动态触发设 initFetchOn,添加态不发空参全量请求。

测试全绿(platform-converter + platform-metadata 共 490,0 失败 0 错误)。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 16:32:50 +08:00
d427be2802 feat(picker): 列筛选下推,支持表单级联(组织→部门→岗位)
PickerController.list() 在 q 模糊查之后追加 applyColumnFilters:把请求里
按真实表列名传入的等值过滤参(白名单=该表真实列,排除 q/page/perPage/op
/value/_id/asUser/roles/asDepart/asOrg 等控制参)下推为等值条件,空值跳过,
escapeLikeValue 防注入。

配合转换器 filterscript 级联:上级选择框变化后 amis 以 &COL=${TRIG} 重拉
本选择框 source,由此端点据列值过滤,实现组织→部门→岗位的联动下拉。

PickerControllerTest 扩充覆盖列筛选/白名单/空值/转义。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 16:32:33 +08:00
abc32af6e9 fix(flow): _SEARCH 解析改 real-first,忠实旧引擎不再无脑合成
旧引擎 FlowServiceImpl.getFlowDefinition 只按 id 从 sys_serviceflow 读
存储流,无运行时合成(默认流在建实体时 addDefaultFlowService 已落库)。
原 EIP4 对所有 _SEARCH 一律合成默认流,盖住了 605 个真实定制流——致约
107 个列表打不开(合成默认流 order by CREATETIME,但表无 createtime 列)
+ 约 157 个排序错(真实流 start 脚本里的自定义排序/join/过滤被无视,
如登录历史 order by LOGINTIME DESC)。

改为 real-first:有真实 serviceflow 就优先真实流(NAMED_READ/WRITE,
跑其存储定义的正确语义),仅未迁默认流的实体才合成兜底。这样所有操作
(_ADD/_UPDATE/_LOAD/_SUBMIT 本就 real-first)统一为「读存储流」,与旧
系统一致。real-first 不会比旧系统更错——跑的就是旧系统跑的同一存储流;
真报错旧系统亦然(数据权限校验 / 缺表)。

A/B 验证(650 个 _SEARCH 引用):基线 OK=564 ERR=86 → real-first
OK=594 ERR=56,新修 33(含 SYS_USERLOGIN_HISTORY_SEARCH),3 个「回归」
经核为忠实暴露(2 个真实流的员工档案数据权限校验、1 个真实流引用缺表
PM_PROJECTNODEDATA),非 EIP4 执行 bug。

FlowNameResolverTest +1(searchSuffixWithRealFlow_prefersNamedRead)。

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-17 16:32:23 +08:00
14 changed files with 1826 additions and 48 deletions

View File

@@ -276,7 +276,7 @@ public final class BatchConvertCli {
csvRows.add(new String[]{"view_template_id", "name", "type", "root", "grade",
"gate1_schema_valid", "mapping_notes", "onEvent_attached", "reasons"});
String sql = "SELECT view_template_id, name, type, xml::text AS xmltext "
String sql = "SELECT view_template_id, name, type, engineclass, xml::text AS xmltext "
+ "FROM view_template ORDER BY type, view_template_id";
try (PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs = ps.executeQuery()) {
@@ -284,6 +284,7 @@ public final class BatchConvertCli {
String id = rs.getString("view_template_id").trim();
String name = rs.getString("name");
int type = rs.getInt("type");
String engineclass = rs.getString("engineclass"); // 机制①:定制视图 Java delta 注入用
String xml = rs.getString("xmltext");
if (xml == null || xml.isBlank()) {
@@ -295,8 +296,8 @@ public final class BatchConvertCli {
List<String> notes = new ArrayList<>();
// F2-13:传 view_template.name 作为 title 来源;WS-C:传 templateId 使 type=3 树 source
// 指向 /api/template/{id}/tree(修 undefined 标签 + 可编辑)
ConversionResult result = converter.convertGraded(xml, id, name, notes, pageResolver);
// 指向 /api/template/{id}/tree(修 undefined 标签 + 可编辑);机制①:传 engineclass 注入定制 delta
ConversionResult result = converter.convertGraded(xml, id, engineclass, name, notes, pageResolver);
boolean gate1 = false;
boolean onEventAttached = false;
if (result.getSchema() != null) {

View File

@@ -0,0 +1,467 @@
package com.eip4.platform.converter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.function.Function;
/**
* 机制①:engineclass 定制 delta 注入(EIP3→EIP4 framework 定制视图迁移)。
*
* <p>老系统的"定制视图"=数据驱动 XML(view_template/view_page) 由基类 {@code *TemplateComponent}
* (默认模板引擎)渲染,大多数功能(列/查询/增删改查/表单)来自 XML;但配了 {@code engineclass} 的视图,
* 有个 Java 子类 EXTENDS 基类,在默认引擎之上**加/改**了东西(新按钮、重写某按钮行为、定制弹窗)。
* 转换器已复刻"默认引擎页"(吃 XML),但抓不到 Java engineclass 的 delta——本类按 engineclass FQN
* 注册这些 delta,转换器转好默认页后**追加注入**到工具栏(默认页不变,仅 append)。
*
* <p>范例(用户管理 {@code UserManageView}): bindingToolbar() 在 super 之上 buildMasterPositionBtn()
* 加「设置主岗位」(弹窗 SYS_POSITIONUSER_SEARCH 列岗位单选 → SYS_POSITIONUSER_UPDATEMASTER)。
*
* <p>未注册的 engineclass → 无 delta(默认引擎页即够)。按钮 builder 入参=该 crud 主键列名(primaryField,
* 如 {@code SYS_USER_ID}),供 {@code ${selectedItems[0].<PK>}} 选中行取值。
*/
public final class EngineclassDelta {
/** engineclass FQN → 该视图要在默认工具栏之上追加的定制按钮 builder 列表(入参=primaryField)。 */
private static final Map<String, List<Function<String, Map<String, Object>>>> REGISTRY = new HashMap<>();
/**
* engineclass FQN → 整页 schema 改写器列表。用于「非 crud 加按钮」类 delta:移除/改写默认引擎页已生成的
* 元素(如 type=3 树页移除右表单增删按钮、改标题)。入参=(整页 schema, ConversionResult 供记 note)。
*/
private static final Map<String, List<BiConsumer<Map<String, Object>, ConversionResult>>> MUTATORS = new HashMap<>();
static {
// 用户管理:Java engineclass(UserManageView.bindingToolbar)在默认页之上加 2 个按钮。
// ①设置主岗位(SYS_POSITIONUSER_SEARCH/UPDATEMASTER 保真层已就绪);
// ②查看用户菜单(UserRoleView 用户可见菜单树,接 /api/admin/user/{userId}/menu)。
register("com.dsasp.clinet.organize.view.UserManageView",
EngineclassDelta::masterPositionButton,
EngineclassDelta::userMenuButton);
// 系统日志查询:Java engineclass(SystemLogMainView.bindingDataView)在默认页之上加 2 个删除按钮
// ①通过类型删除(LogType 弹窗下拉 → systemLogManager.deleteByType);②全部删除(systemLogManager.deleteAll)。
// 顺序贴老引擎(先 deleteByType 后 deleteAll)。crud 内 ajax 成功后 amis 自动重载列表(无需显式 reload)。
register("com.dsasp.client.datadic.view.SystemLogMainView",
EngineclassDelta::logDeleteByTypeButton,
EngineclassDelta::logDeleteAllButton);
// 用户登录历史:SysUserLoginHistoryMainView.deleteRecord 加「根据查询条件删除记录」(读 filter
// USERID+LOGINTIME → systemLogManager.deleteByLoginTime,确认框)。接 /api/admin/log/delete-by-logintime。
register("com.dsasp.client.datadic.view.SysUserLoginHistoryMainView",
EngineclassDelta::loginHistoryDeleteButton);
// 用户登录操作信息:SysUserLoginInfoMainView.createViewLoginHistoryButton 加「查看登录记录」——下钻到
// 登录历史(edc05980),带选中行用户 id(USERID)+本页 OPTIMES 时间区间(LOGINTIME)作默认查询。
register("com.dsasp.client.datadic.view.SysUserLoginInfoMainView",
EngineclassDelta::loginInfoViewHistoryButton);
// 功能模板下载模板管理(0246d4bd)/设置(13accf09):同 engineclass。FuncDownloadComponent.refreshRightLayout
// 在默认树页之上——移除右表单「添加/删除」按钮(附件随菜单/实体生成不应手工增删)+ 右表单标题改「编辑模板附件」。
// 非 crud 加按钮,走整页改写器(MUTATORS)。
registerMutator("com.dsasp.client.viewframework.component.FuncDownloadComponent",
EngineclassDelta::funcDownloadDelta);
}
private EngineclassDelta() {
}
@SafeVarargs
private static void register(String fqn, Function<String, Map<String, Object>>... builders) {
REGISTRY.put(fqn, List.of(builders));
}
@SafeVarargs
private static void registerMutator(String fqn, BiConsumer<Map<String, Object>, ConversionResult>... mutators) {
MUTATORS.put(fqn, List.of(mutators));
}
/**
* 把 {@code engineclass} 的定制 delta 注入 {@code schema}(默认引擎已转好的页):
* ① crud 列表页 → 工具栏追加按钮({@link #REGISTRY});② 任意页 → 整页改写({@link #MUTATORS},
* 如 type=3 树页移除增删按钮/改标题)。未注册 → no-op。
*/
public static void apply(Map<String, Object> schema, String engineclass, ConversionResult result) {
if (schema == null || engineclass == null) {
return;
}
applyToolbarButtons(schema, engineclass, result);
applyMutators(schema, engineclass, result);
}
/** ① crud 工具栏追加按钮:仅 {@code body.type=crud},插在 {@code pagination} 之前;未注册/非 crud → no-op。 */
@SuppressWarnings("unchecked")
private static void applyToolbarButtons(Map<String, Object> schema, String engineclass, ConversionResult result) {
List<Function<String, Map<String, Object>>> builders = REGISTRY.get(engineclass);
if (builders == null || builders.isEmpty()) {
return;
}
Object bodyObj = schema.get("body");
if (!(bodyObj instanceof Map)) {
return;
}
Map<String, Object> body = (Map<String, Object>) bodyObj;
if (!"crud".equals(body.get("type"))) {
return; // 仅 crud 列表页注入工具栏按钮(tree/group/page 等暂不在此机制)
}
Object tbObj = body.get("headerToolbar");
if (!(tbObj instanceof List)) {
return;
}
List<Object> toolbar = (List<Object>) tbObj;
String pkField = String.valueOf(body.getOrDefault("primaryField", ""));
int insertAt = toolbar.indexOf("pagination");
if (insertAt < 0) {
insertAt = toolbar.size();
}
for (Function<String, Map<String, Object>> b : builders) {
Map<String, Object> btn = b.apply(pkField);
toolbar.add(insertAt++, btn);
if (result != null) {
result.note("engineclass[" + engineclass + "] 注入定制按钮: " + btn.get("label"));
}
}
}
/** ② 整页改写器:对注册的 mutator 逐个施加到整页 schema(任意 body 类型);未注册 → no-op。 */
private static void applyMutators(Map<String, Object> schema, String engineclass, ConversionResult result) {
List<BiConsumer<Map<String, Object>, ConversionResult>> mutators = MUTATORS.get(engineclass);
if (mutators == null || mutators.isEmpty()) {
return;
}
for (BiConsumer<Map<String, Object>, ConversionResult> m : mutators) {
m.accept(schema, result);
}
}
// ── 功能模板下载模板管理/设置 · 去增删按钮 + 改标题 ─────────────────────────
/**
* FuncDownloadComponent.refreshRightLayout 的 EIP4 等价改写。转换后 type=3 树页结构=
* {@code grid → 列[左 input-tree][右 button-toolbar[添加] + form]}。改写:
* <ul>
* <li>① 移除右侧 button-toolbar 内「添加/删除」按钮(老 cl.removeComponent(insert)/(del)——附件记录随
* 菜单/实体生成不应手工增删);toolbar 因此变空则整条移除。</li>
* <li>② 右表单标题改「编辑模板附件」(老 panel.setCaption("编辑模板附件"))。</li>
* </ul>
* <b>未做</b>:老「仅 pojo.VIEW_TEMPLATEID 非空才显示右表单」的门控——amis 表单 {@code visibleOn} 依赖
* 自身 initApi 数据成循环(隐藏则不 fetch),正解需树节点携带 VIEW_TEMPLATEID(改 TemplateTreeController),
* 价值低,暂延后。
*/
@SuppressWarnings("unchecked")
private static void funcDownloadDelta(Map<String, Object> schema, ConversionResult result) {
Object bodyObj = schema.get("body");
if (!(bodyObj instanceof Map)) {
return;
}
Object colsObj = ((Map<String, Object>) bodyObj).get("columns");
if (!(colsObj instanceof List)) {
return;
}
// 注:转换器的列 body 是不可变 List.of(...)(buildEditableTreeMasterDetail),不能原地 removeIf;
// 列 map 本身是可变 LinkedHashMap → 重建 body 列表回填。
for (Object colObj : (List<Object>) colsObj) {
if (!(colObj instanceof Map)) {
continue;
}
Map<String, Object> col = (Map<String, Object>) colObj;
Object colBodyObj = col.get("body");
if (!(colBodyObj instanceof List)) {
continue;
}
List<Object> rebuilt = new ArrayList<>();
for (Object n : (List<Object>) colBodyObj) {
if (n instanceof Map) {
Map<String, Object> m = (Map<String, Object>) n;
if ("button-toolbar".equals(m.get("type"))) {
if (stripToolbarAddDel(m, result)) {
continue; // ① 剥「添加/删除」后空 toolbar → 丢弃整条
}
} else if ("form".equals(m.get("type"))) {
// ② 右表单标题改「编辑模板附件」
Object old = m.put("title", "编辑模板附件");
if (result != null) {
result.note("engineclass[FuncDownloadComponent] 右表单标题改写: "
+ old + " → 编辑模板附件");
}
}
}
rebuilt.add(n);
}
col.put("body", rebuilt);
}
}
/**
* 剥除 button-toolbar 内「添加/删除」按钮(重建 buttons 列表回填,兼容不可变源);剥后为空返回 true(供丢弃整条)。
*/
@SuppressWarnings("unchecked")
private static boolean stripToolbarAddDel(Map<String, Object> toolbar, ConversionResult result) {
Object btnsObj = toolbar.get("buttons");
if (!(btnsObj instanceof List)) {
return false;
}
List<Object> kept = new ArrayList<>();
boolean removed = false;
for (Object b : (List<Object>) btnsObj) {
if (b instanceof Map
&& ("添加".equals(((Map<String, Object>) b).get("label"))
|| "删除".equals(((Map<String, Object>) b).get("label")))) {
removed = true;
continue;
}
kept.add(b);
}
if (removed) {
toolbar.put("buttons", kept);
if (result != null) {
result.note("engineclass[FuncDownloadComponent] 移除右表单「添加/删除」按钮");
}
}
return kept.isEmpty();
}
// ── 用户管理 · 设置主岗位 ──────────────────────────────────────────────
/**
* 「设置主岗位」按钮:选 1 用户 → 弹窗 form。initApi 拉该用户岗位(SYS_POSITIONUSER_SEARCH by USERID),
* radios 单选岗位(label=POSITIONID_DISPLAY__, value=SYS_POSITIONUSER_ID,预选 ISMASTER 现任主岗位),
* 提交 SYS_POSITIONUSER_UPDATEMASTER(USERID + MASTERPOSITION)。复刻 UserManageView.buildMasterPositionWin。
*/
private static Map<String, Object> masterPositionButton(String pkField) {
String userSel = "${selectedItems[0]." + pkField + "}";
// radios 选项由 source API 直接加载该用户岗位(SYS_POSITIONUSER_SEARCH 返 data.items → 映射为 options),
// USERID 由 dialog 数据域注入(复用 navigation 验证过的 dialog.data 模式,比 form initApi 直引 selectedItems 可靠)。
Map<String, Object> radiosSource = mapOf(
"method", "post",
"url", "/api/flow/SYS_POSITIONUSER_SEARCH",
"data", mapOf("USERID", "${USERID}"),
"responseData", mapOf("options", "${items}"));
Map<String, Object> radios = mapOf(
"type", "radios",
"name", "MASTERPOSITION",
"label", "主岗位",
"source", radiosSource,
"labelField", "POSITIONID_DISPLAY__",
"valueField", "SYS_POSITIONUSER_ID");
Map<String, Object> submitApi = mapOf(
"method", "post",
"url", "/api/flow/SYS_POSITIONUSER_UPDATEMASTER",
"data", mapOf("USERID", "${USERID}", "MASTERPOSITION", "${MASTERPOSITION}"));
// form initApi 预选现任主岗位:拉该用户岗位,responseData 取 ISMASTER 真的那条 SYS_POSITIONUSER_ID
// 设为 MASTERPOSITION 字段默认值(radios 同名 + 选项 value 匹配 → 自动选中)。无主岗位则不预选。
// 复刻 UserManageView.buildMasterPositionWin 的 if(ISMASTER) group.setValue(po.get_ID())。
Map<String, Object> initApi = mapOf(
"method", "post",
"url", "/api/flow/SYS_POSITIONUSER_SEARCH",
"data", mapOf("USERID", "${USERID}"),
"responseData", mapOf("MASTERPOSITION",
"${ARRAYFILTER(items, item => item.ISMASTER == true || item.ISMASTER == 1)[0].SYS_POSITIONUSER_ID}"));
Map<String, Object> form = mapOf(
"type", "form",
"initApi", initApi,
"body", List.of(radios),
"api", submitApi);
Map<String, Object> dialog = mapOf(
"type", "dialog",
"title", "设置主岗位",
"size", "md",
// 选中行用户主键注入弹窗数据域 → 内层 source/submit 引 ${USERID}(选中无岗位用户则 options 空)
"data", mapOf("USERID", userSel),
"body", form);
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "设置主岗位");
btn.put("label", "设置主岗位");
btn.put("icon", "fa fa-user-tag");
// 恰好选中 1 条才可点(老系统 set.size()!=1 报错)
btn.put("disabledOn", "${!selectedItems || selectedItems.length !== 1}");
btn.put("actionType", "dialog");
btn.put("dialog", dialog);
return btn;
}
// ── 用户管理 · 查看用户菜单 ────────────────────────────────────────────
/**
* 「查看用户菜单」按钮:选 1 用户 → 弹窗只读树显示该用户**可见菜单**(按 view_sys_usermenuid 裁剪)。
* source 接 {@code GET /api/admin/user/{userId}/menu}(返 {roots:[...]}),responseData 映射 roots→options,
* input-tree(disabled) 用 name/id 渲染嵌套菜单树。复刻 UserManageView.buildUserRoleBtn → UserRoleView。
*/
private static Map<String, Object> userMenuButton(String pkField) {
String userSel = "${selectedItems[0]." + pkField + "}";
Map<String, Object> treeSource = mapOf(
"method", "get",
"url", "/api/admin/user/${USERID}/menu",
"responseData", mapOf("options", "${roots}"));
// 只读查看树:不能用 disabled(整树变灰 + 不可展开/选中,体验差,用户反馈);改用 static + 可展开滚动搜索。
// 展开/搜索/滚动均可用,选中无提交副作用(弹窗只有「关闭」按钮,不入表单提交)。
Map<String, Object> tree = mapOf(
"type", "input-tree",
"name", "__userMenu",
"label", "",
"source", treeSource,
"labelField", "name",
"valueField", "id",
"showOutline", true,
"initiallyOpen", true,
"searchable", true,
"heightAuto", true);
Map<String, Object> dialog = mapOf(
"type", "dialog",
"title", "查看用户菜单",
"size", "md",
"data", mapOf("USERID", userSel),
"body", tree,
"actions", List.of(mapOf("type", "button", "actionType", "close", "label", "关闭")));
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "查看用户菜单");
btn.put("label", "查看用户菜单");
btn.put("icon", "fa fa-sitemap");
btn.put("disabledOn", "${!selectedItems || selectedItems.length !== 1}");
btn.put("actionType", "dialog");
btn.put("dialog", dialog);
return btn;
}
// ── 系统日志查询 · 通过类型删除 ────────────────────────────────────────
/**
* 「通过类型删除」按钮:弹窗选日志类型(Errors/Info/Debug/Warnings) → 提交 deleteByType。
* 复刻 SystemLogMainView.deleteByType(ComboBox(SystemLogManager.LogType.values) → systemLogManager
* .deleteByType(value))。选项为固定枚举(LogType 的 value),接保真层端点 /api/admin/log/delete-by-type。
* 不依赖选中行(pkField 忽略);提交成功后 amis crud 自动重载。
*/
private static Map<String, Object> logDeleteByTypeButton(String pkField) {
List<Map<String, Object>> opts = List.of(
mapOf("label", "Errors", "value", "Errors"),
mapOf("label", "Info", "value", "Info"),
mapOf("label", "Debug", "value", "Debug"),
mapOf("label", "Warnings", "value", "Warnings"));
Map<String, Object> select = mapOf(
"type", "select",
"name", "LOGTYPE",
"label", "日志类型",
"options", opts,
"required", true);
Map<String, Object> submitApi = mapOf(
"method", "post",
"url", "/api/admin/log/delete-by-type",
"data", mapOf("type", "${LOGTYPE}"));
Map<String, Object> form = mapOf(
"type", "form",
"body", List.of(select),
"api", submitApi);
Map<String, Object> dialog = mapOf(
"type", "dialog",
"title", "通过类型删除",
"size", "sm",
"body", form);
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "通过类型删除");
btn.put("label", "通过类型删除");
btn.put("icon", "fa fa-filter");
btn.put("level", "warning");
btn.put("actionType", "dialog");
btn.put("dialog", dialog);
return btn;
}
// ── 系统日志查询 · 全部删除 ────────────────────────────────────────────
/**
* 「全部删除」按钮:确认 → 删除全部系统日志。复刻 SystemLogMainView.deleteAll(systemLogManager.deleteAll())。
* 不依赖选中行;confirmText 二次确认(老引擎无确认,新 UI 加上防误删);crud 内 ajax 成功后自动重载。
*/
private static Map<String, Object> logDeleteAllButton(String pkField) {
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "全部删除");
btn.put("label", "全部删除");
btn.put("icon", "fa fa-trash");
btn.put("level", "danger");
btn.put("actionType", "ajax");
btn.put("confirmText", "确认删除全部系统日志?此操作不可恢复。");
btn.put("api", mapOf("method", "post", "url", "/api/admin/log/delete-all"));
return btn;
}
// ── 用户登录历史 · 根据查询条件删除记录 ──────────────────────────────────
/**
* 「根据查询条件删除记录」按钮:读 crud filter 的 USERID(多选 picker)+ LOGINTIME(datetime-range) →
* 提交 deleteByLoginTime。复刻 SysUserLoginHistoryMainView.deleteRecord(确认框 → searchComponent
* .getValue() 取 USERID/LOGINTIME → systemLogManager.deleteByLoginTime)。不依赖选中行;confirmText
* 提示无条件即删全部(老引擎同语义);crud 内 ajax 成功后自动重载。
*/
private static Map<String, Object> loginHistoryDeleteButton(String pkField) {
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "根据查询条件删除记录");
btn.put("label", "根据查询条件删除记录");
btn.put("icon", "fa fa-trash");
btn.put("level", "danger");
btn.put("actionType", "ajax");
btn.put("confirmText", "确认按当前查询条件删除登录历史记录吗?(未设查询条件将删除全部登录历史,不可恢复)");
btn.put("api", mapOf(
"method", "post",
"url", "/api/admin/log/delete-by-logintime",
"data", mapOf("USERID", "${USERID}", "LOGINTIME", "${LOGINTIME}")));
return btn;
}
// ── 用户登录操作信息 · 查看登录记录(下钻) ────────────────────────────────
/** 老登录历史模板 view_template_id(SysUserLoginInfoMainView 硬编码引用,作下钻目标 schema)。 */
private static final String LOGIN_HISTORY_TEMPLATE_ID = "edc05980-022b-45a2-8aea-9619e07615ae";
/**
* 「查看登录记录」按钮:选 1 行 → 弹窗内嵌登录历史(edc05980)列表,按该用户(USERID=选中行主键)+本页
* OPTIMES 时间区间(LOGINTIME)默认过滤。复刻 SysUserLoginInfoMainView.createViewLoginHistoryButton
* (new SysUserLoginHistoryMainView + setDefaultSearch{USERID,LOGINTIME})。
* 弹窗 data 注入 USERID/LOGINTIME → 内嵌 crud filter 同名字段据此默认过滤。
*/
private static Map<String, Object> loginInfoViewHistoryButton(String pkField) {
String userSel = "${selectedItems[0]." + pkField + "}";
Map<String, Object> service = mapOf(
"type", "service",
"schemaApi", "get:/api/page/schema/" + LOGIN_HISTORY_TEMPLATE_ID + "?format=amis");
Map<String, Object> dialog = mapOf(
"type", "dialog",
"title", "登录记录",
"size", "lg",
// 选中行用户 id + 本页 OPTIMES 时间区间注入弹窗域 → 内嵌登录历史 crud 的 USERID/LOGINTIME 过滤默认值
"data", mapOf("USERID", userSel, "LOGINTIME", "${OPTIMES}"),
"body", service,
"actions", List.of(mapOf("type", "button", "actionType", "close", "label", "关闭")));
Map<String, Object> btn = new LinkedHashMap<>();
btn.put("type", "button");
btn.put("id", "查看登录记录");
btn.put("label", "查看登录记录");
btn.put("icon", "fa fa-history");
btn.put("disabledOn", "${!selectedItems || selectedItems.length !== 1}");
btn.put("actionType", "dialog");
btn.put("dialog", dialog);
return btn;
}
/** 有序 map 字面量助手(key,value 交替)。 */
private static Map<String, Object> mapOf(Object... kv) {
Map<String, Object> m = new LinkedHashMap<>();
for (int i = 0; i + 1 < kv.length; i += 2) {
m.put(String.valueOf(kv[i]), kv[i + 1]);
}
return m;
}
}

View File

@@ -9,6 +9,8 @@ import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
@@ -46,6 +48,13 @@ public class TemplateToAmisConverter {
*/
private String currentTemplateId;
/**
* 当前模板 engineclass(view_template.engineclass FQN)。机制①:默认引擎页转好后,
* 据此把老系统 Java engineclass 在默认模板引擎之上加/改的定制按钮({@link EngineclassDelta})注入转换页。
* 缺省 null(普通数据驱动页/旧重载/单测)→ 不注入任何 delta,默认引擎页不变。
*/
private String currentEngineclass;
public TemplateToAmisConverter(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@@ -105,11 +114,24 @@ public class TemplateToAmisConverter {
public ConversionResult convertGraded(String templateXml, String templateId, String templateName,
List<String> mappingNotes,
Function<String, String> pageResolver) {
return convertGraded(templateXml, templateId, null, templateName, mappingNotes, pageResolver);
}
/**
* 分级转换主入口(含 engineclass,机制①:注入老系统 Java engineclass 定制 delta 按钮)。
*
* @param engineclass view_template.engineclass(FQN);null=普通数据驱动页,不注入任何 delta
*/
public ConversionResult convertGraded(String templateXml, String templateId, String engineclass,
String templateName, List<String> mappingNotes,
Function<String, String> pageResolver) {
this.currentTemplateId = (templateId != null && !templateId.isBlank()) ? templateId.trim() : null;
this.currentEngineclass = (engineclass != null && !engineclass.isBlank()) ? engineclass.trim() : null;
try {
return convertGradedInternal(templateXml, templateName, mappingNotes, pageResolver);
} finally {
this.currentTemplateId = null; // 防跨模板泄漏
this.currentTemplateId = null; // 防跨模板泄漏
this.currentEngineclass = null;
}
}
@@ -146,6 +168,10 @@ public class TemplateToAmisConverter {
} catch (Exception e) {
result.fail("转换异常: " + e.getClass().getSimpleName() + " " + safeMsg(e));
}
// 机制①:默认引擎页转好后,按 engineclass 注入老系统 Java 定制 delta 按钮(默认页不变,仅追加)。
if (currentEngineclass != null && result.getSchema() != null) {
EngineclassDelta.apply(result.getSchema(), currentEngineclass, result);
}
return result;
}
@@ -627,6 +653,26 @@ public class TemplateToAmisConverter {
result.note("button[read] " + btnName + " → dialog 加载 /api/page/schema/" + editFormTemplateId
+ "(查看态 static=true,pageid=" + pageId + ")");
}
case "navigation" -> {
// type=navigation:工具栏导航按钮(如客户信息「升级历史」),funcid 指向另一功能页,
// onloadscript 在目标页设默认查询条件(老系统 setDefaultSearch)。通用映射:
// actionType=dialog,dialog 内嵌 service(schemaApi=/api/page/schema/{funcid}) 渲染目标页,
// 并把当前选中行主键(${selectedItems[0].<PK>})以主键列名为键注入 dialog data →
// 目标 crud 列表 api 自动携带为查询参数(= setDefaultSearch 默认过滤),全库 navigation 通用受益。
String funcId = b.attributeValue(ATTR_FUNC_ID, "");
String navTitle = UiTypeMapper.firstNonBlank(b.attributeValue("funcname"), btnName);
String pkCol = table + "_ID";
boolean needSelected = !"false".equals(b.attributeValue("isneedselected"));
btn.put("actionType", "dialog");
if (needSelected) {
btn.put("disabledOn", DISABLED_ON_NO_SELECTION);
}
Map<String, Object> dlg = buildNavigationDialog(navTitle, funcId, pkCol, needSelected, result);
btn.put("dialog", dlg);
result.note("button[navigation] " + btnName + " → dialog service schemaApi=/api/page/schema/"
+ funcId + "(funcname=" + navTitle + ",注入默认查询 " + pkCol + "=选中行主键"
+ (needSelected ? ",需选中" : "") + ")");
}
default -> result.note("button[" + btnType + "] " + btnName + " → 普通按钮占位");
}
toolbar.add(btn);
@@ -710,6 +756,53 @@ public class TemplateToAmisConverter {
return btn;
}
/**
* type=navigation 导航按钮的目标页弹窗:service 加载 {@code /api/page/schema/{funcId}} 渲染目标功能页,
* 并把当前选中行主键以主键列名为键注入 dialog data(amis 数据域下渗到内嵌 crud 的列表 api 查询参数),
* 等价老系统 onloadscript 的 {@code setDefaultSearch({<PK>: value})} 默认过滤。通用实现,全库 navigation 受益。
*
* @param title 弹窗标题(取 funcname,回退按钮名)
* @param funcId 目标功能页 view_template_id(navigation funcid)
* @param pkCol 源 crud 主键列名(注入键名 + 选中行取值列)
* @param needSelected 是否需选中行(isneedselected≠false);true 时才注入选中行主键默认查询
* @param result 转换结果台账
*/
private Map<String, Object> buildNavigationDialog(String title, String funcId,
String pkCol, boolean needSelected,
ConversionResult result) {
Map<String, Object> dlg = new LinkedHashMap<>();
dlg.put("type", "dialog");
dlg.put("title", title);
dlg.put("size", "lg");
if (funcId == null || funcId.isBlank()) {
Map<String, Object> tpl = new LinkedHashMap<>();
tpl.put("type", "tpl");
tpl.put("tpl", "该导航按钮未配置目标功能页");
dlg.put("body", tpl);
result.degrade("button[navigation] 无 funcid → 诚实降级(无目标页可渲染)");
dlg.put("actions", List.of(new LinkedHashMap<>(Map.of(
"type", "button", "actionType", "close", "label", "关闭"))));
return dlg;
}
// 注入默认查询:把选中行主键以主键列名为键放进 dialog data,目标 crud 列表 api 自动携带为查询参数
// (= setDefaultSearch 默认过滤)。仅在需选中时注入;不需选中(独立导航)则不注入、纯打开目标页。
if (needSelected && pkCol != null && !pkCol.isBlank()) {
Map<String, Object> dlgData = new LinkedHashMap<>();
dlgData.put(pkCol, selectedSingleIdExpr(pkCol));
dlg.put("data", dlgData);
}
Map<String, Object> service = new LinkedHashMap<>();
service.put("type", "service");
service.put("schemaApi", "get:/api/page/schema/" + funcId.trim() + "?format=amis");
dlg.put("body", service);
dlg.put("actions", List.of(new LinkedHashMap<>(Map.of(
"type", "button", "actionType", "close", "label", "关闭"))));
return dlg;
}
/**
* F2-17 / 服务流分派:构造 dialog body 为 service 加载 /api/page/schema/{templateId} 的 dialog。
*
@@ -1054,9 +1147,16 @@ public class TemplateToAmisConverter {
if (multiple) {
item.put("multiple", true);
}
// type=101 树形选择框(主部门 org→部门 / 主岗位 org→部门→岗位):目标是叶子实体(部门/岗位),
// 上层 org/部门仅供导航 → onlyLeaf 限定只能选叶子(修「主部门应只能选部门,实际都能选」)。
// type=3 组织树(所属组织)任意层级 org 均为合法选项,不加 onlyLeaf。
if (isLeafSelectorDialog(dialogId)) {
item.put("onlyLeaf", true);
}
result.note("树选择 " + name + " → dialogid=" + dialogId
+ " 是 type=3 树模板 → tree-select(source=/api/template/.../tree),非扁平 picker"
+ "(修上级菜单等层级引用显列表选择框)");
+ " 是 type=3/101 树模板 → tree-select(source=/api/template/.../tree"
+ (isLeafSelectorDialog(dialogId) ? ",onlyLeaf 限选叶子实体" : "") + "),非扁平 picker"
+ "(修上级菜单/主部门/主岗位等层级引用显列表选择框)");
} else if (!dialogId.isBlank() && isType4Dialog(dialogId)) {
// ④:树+grid 选择框——dialogid 指向 type=4「树+grid」模板(<treetemplate ref/> + <gridtemplate
// ref/ rcolumnname/>,如「功能管理」)→ 把扁平 picker 改写为「弹窗内 = 左分类树过滤 + 右 CRUD 表格」
@@ -1069,6 +1169,115 @@ public class TemplateToAmisConverter {
}
}
/** 动态过滤绑定 {@code .put("COL", getFieldValue("TRIG"))}(容忍任意 map 变量名/空白)。 */
private static final Pattern FILTER_DYNAMIC_PUT = Pattern.compile(
"\\.put\\s*\\(\\s*\"([^\"]+)\"\\s*,\\s*getFieldValue\\s*\\(\\s*\"([^\"]+)\"\\s*\\)\\s*\\)");
/** 动态过滤绑定(方括号语法){@code map["COL"] = getFieldValue("TRIG")}。 */
private static final Pattern FILTER_DYNAMIC_BRACKET = Pattern.compile(
"\\[\\s*\"([^\"]+)\"\\s*\\]\\s*=\\s*getFieldValue\\s*\\(\\s*\"([^\"]+)\"\\s*\\)");
/** 常量过滤绑定 {@code .put("COL", 3)} / {@code .put("COL", "v")}。 */
private static final Pattern FILTER_CONST_PUT = Pattern.compile(
"\\.put\\s*\\(\\s*\"([^\"]+)\"\\s*,\\s*(?:\"([^\"]*)\"|(\\d+))\\s*\\)");
/** 常量过滤绑定(方括号语法){@code map["COL"] = 3} / {@code map["COL"] = "v"}。 */
private static final Pattern FILTER_CONST_BRACKET = Pattern.compile(
"\\[\\s*\"([^\"]+)\"\\s*\\]\\s*=\\s*(?:\"([^\"]*)\"|(\\d+))\\s*[;\\n]");
/**
* 复杂标记——脚本含任一则<b>整条跳过</b>(绝不"只搬一半"导致少过滤/显多余数据):原始 SQL 片段、
* 引擎特殊条件键 {@code WhereClause}、运行时服务调用、控制流、字符串拼接。这些 filterscript 唯有
* 运行时真跑老 Groovy 才能忠实复现(P3 兜底),静态译只会破坏正确性。
*/
private static final Pattern FILTER_COMPLEX_MARKER = Pattern.compile(
"CustomSearchConditional|loadPOJO|GetServicesFunction|EnviromentGet|WhereClause"
+ "|\\bSELECT\\b|\\bNOT\\s+IN\\b|\\bEXISTS\\b|\\bWHERE\\b|\\bilike\\b"
+ "|\\bif\\b|\\bfor\\b|\\bwhile\\b|\\+=",
Pattern.CASE_INSENSITIVE);
/**
* P1 级联过滤(组织→部门→岗位等):把 view_page 字段 {@code filterscript} 的「按其它字段值过滤本字段
* 选项」语义译成 amis source 上的数据映射查询参,<b>amis 对含 {@code ${var}} 的 source 自动监听重拉</b>
* (与 type=4 右表 {@code node=${tree}} 同机制),从而过滤 + 重拉一并解决,无需 onEvent。
*
* <p>仅作用于已渲为 {@code select}(ComboBox)且 source 为字符串的字段:读其 {@code filterscript} 属性
* → 在 {@code pageScripts} 取脚本体 → 用 {@link #FILTER_PUT_PATTERN} 抽 {@code (FILTERCOL, TRIGGER)} 对
* → 把 {@code &FILTERCOL=${TRIGGER}} 追加进 source(已含该参则跳过,幂等)。后端 {@code /api/picker/{表}/list}
* 接受表真实列名作等值过滤参(见 PickerController)。非该模式的 filterscript(纯常量/复杂脚本)<b>不改</b>
* source(P3 通用脚本兜底另案)。
*
* @param item 已 {@link UiTypeMapper#mapField} + {@link #enrichFieldRefs} 处理过的字段项
* @param f 源 {@code <field>}(取 {@code filterscript} 属性)
* @param pageScripts 本页 {@code <scripts>} 的 {@code key → 脚本体} 映射(无则不级联)
*/
private void applyFilterscriptCascade(Map<String, Object> item, Element f,
Map<String, String> pageScripts, ConversionResult result) {
if (item == null || f == null || pageScripts == null || pageScripts.isEmpty()) {
return;
}
// 仅级联 select(ComboBox 远程选项)且 source 为字符串:picker/tree-select/static 等不在此列
if (!"select".equals(item.get("type")) || !(item.get("source") instanceof String src)) {
return;
}
String filterKey = f.attributeValue("filterscript", "").trim();
if (filterKey.isBlank()) {
return;
}
String script = pageScripts.get(filterKey);
if (script == null || script.isBlank()) {
return;
}
// 正确性护栏:含原始 SQL / 服务调用 / 控制流 / WhereClause 的复杂 filterscript 整条跳过——
// 静态只能译简单等值,搬一半会丢复杂限制反而显多余数据;复杂的留 P3 运行时执行兜底。
if (FILTER_COMPLEX_MARKER.matcher(script).find()) {
result.note("filterscript " + f.attributeValue("name", "")
+ " 含复杂条件(SQL/服务/控制流)→ 整条跳过静态级联(待 P3 运行时执行)");
return;
}
String source = src;
String name = f.attributeValue("name", "");
// 已加过滤的列(去重,避免同列动态+常量重复);触发字段集合(保序去重,用于 initFetchOn)
java.util.Set<String> addedCols = new java.util.LinkedHashSet<>();
java.util.LinkedHashSet<String> triggers = new java.util.LinkedHashSet<>();
// ── 动态绑定(.put / 方括号):source 追加 &COL=${TRIG},amis 监听 ${TRIG} 变化自动重拉 ──
for (Pattern p : List.of(FILTER_DYNAMIC_PUT, FILTER_DYNAMIC_BRACKET)) {
Matcher m = p.matcher(script);
while (m.find()) {
String col = m.group(1).trim();
String trig = m.group(2).trim();
if (col.isBlank() || trig.isBlank() || col.equalsIgnoreCase(name)
|| !addedCols.add(col.toUpperCase())) {
continue; // 空 / 自引用 / 该列已加 → 跳过
}
source = source + (source.contains("?") ? "&" : "?") + col + "=${" + trig + "}";
triggers.add(trig);
result.note("filterscript 级联 " + name + ":source 追加 " + col + "=${" + trig
+ "}(amis 监听 ${" + trig + "} 变化自动重拉)");
}
}
// ── 常量绑定(.put / 方括号):source 追加 &COL=<定值>(恒生效,不设 initFetchOn)──
for (Pattern p : List.of(FILTER_CONST_PUT, FILTER_CONST_BRACKET)) {
Matcher m = p.matcher(script);
while (m.find()) {
String col = m.group(1).trim();
String val = m.group(2) != null ? m.group(2) : m.group(3); // 字符串 / 数字字面量
if (col.isBlank() || val == null || val.isBlank() || col.equalsIgnoreCase(name)
|| !addedCols.add(col.toUpperCase())) {
continue;
}
String enc = java.net.URLEncoder.encode(val, java.nio.charset.StandardCharsets.UTF_8);
source = source + (source.contains("?") ? "&" : "?") + col + "=" + enc;
result.note("filterscript 常量 " + name + ":source 追加 " + col + "=" + val + "(固定值过滤)");
}
}
if (!source.equals(src)) {
item.put("source", source);
// 性能:有动态触发字段时设 initFetchOn——添加态触发字段空 → 不发空参全量请求,选了上级才拉;
// 编辑态触发字段已加载有值 → 照常初拉。纯常量过滤无触发字段 → 不设(恒初拉)。
// change 触发的重拉不受 initFetchOn 影响。
if (!triggers.isEmpty()) {
item.put("initFetchOn", "${" + String.join(" && ", triggers) + "}");
}
}
}
/**
* type=4 树+grid 选择框(弹窗内 = 左分类树过滤 + 右 CRUD 表格)的 picker 改写。
*
@@ -1253,8 +1462,15 @@ public class TemplateToAmisConverter {
}
/**
* dialogid(=view_template_id) 指向的模板是否 type=3(树形对话框,绑自引用层级实体)。
* 用于把「上级菜单/父分类」等层级引用的 SelectDialog 从扁平 picker 改写为 tree-select。
* dialogid(=view_template_id) 指向的模板是否「树形对话框」(绑自引用/组织层级实体)→ 渲 tree-select。
* 覆盖两类树根模板:
* <ul>
* <li><b>type=3</b>:树管理页(如组织管理/菜单维护/上级分类,可编辑 + 自引用层级);</li>
* <li><b>type=101</b>:树形选择框(如「部门选择框」138b7ca7 org→部门 / 「岗位选择框」feeee51d org→部门→岗位,
* 只读层级选择器,老系统「主部门/主岗位」等引用它)。此前只认 type=3 → 11 个 type=101 选择框被误渲扁平
* picker 查到树根实体(SYS_ORG),表现为「主部门/主岗位 引用不对,弹出的是组织」。</li>
* </ul>
* source 复用 {@code /api/template/{dialogid}/tree}(TemplateTreeController 鉴权后返完整层级 {label,value,children})。
* 查询失败/非树 → false(保持 picker 基线,零回归)。
*/
private boolean isTreeDialog(String dialogId) {
@@ -1265,7 +1481,25 @@ public class TemplateToAmisConverter {
Integer type = jdbcTemplate.queryForObject(
"SELECT type FROM view_template WHERE view_template_id = ?",
Integer.class, dialogId);
return type != null && type == 3;
return type != null && (type == 3 || type == 101);
} catch (Exception e) {
return false;
}
}
/**
* dialogid 是否「树形选择框」(type=101,如部门选择框/岗位选择框)——目标是叶子实体(部门/岗位),
* 上层 org/部门仅供导航 → tree-select 加 {@code onlyLeaf} 限定只能选叶子。type=3 组织树(任意级 org 合法)不属此类。
*/
private boolean isLeafSelectorDialog(String dialogId) {
if (dialogId == null || dialogId.isBlank()) {
return false;
}
try {
Integer type = jdbcTemplate.queryForObject(
"SELECT type FROM view_template WHERE view_template_id = ?",
Integer.class, dialogId);
return type != null && type == 101;
} catch (Exception e) {
return false;
}
@@ -1395,9 +1629,12 @@ public class TemplateToAmisConverter {
if (fields != null) {
// 列元数据(含 enumeratetype):供 ComboBox 缺省 comboboxid 但 itemisenumerate=true 取枚举字典源
Map<String, String[]> colMeta = loadColumnMeta(entityId, result);
// 本页脚本(key→脚本体):供 filterscript 级联(组织→部门→岗位)解析,与 convertViewPage 同口径
Map<String, String> pageScripts = pageScriptsByKey(pageRoot);
for (Element f : fields.elements("field")) {
Map<String, Object> formItem = UiTypeMapper.mapField(f, result, "editform", colMeta);
enrichFieldRefs(formItem, f, result);
applyFilterscriptCascade(formItem, f, pageScripts, result);
formItems.add(formItem);
}
result.note("form@pageid=" + pageId + " → 解析 view_page 取得 " + formItems.size() + " 字段");
@@ -1522,6 +1759,7 @@ public class TemplateToAmisConverter {
for (Element f : fields.elements("field")) {
Map<String, Object> formItem = UiTypeMapper.mapField(f, result, "editform", colMeta, pageScripts);
enrichFieldRefs(formItem, f, result);
applyFilterscriptCascade(formItem, f, pageScripts, result);
formItems.add(formItem);
}
}
@@ -2491,9 +2729,21 @@ public class TemplateToAmisConverter {
treeSchema.put("heightAuto", true);
// ── 右表单字段(pageid → view_page,UiTypeMapper 忠实映射)──
// 解析 pageRoot:既供字段映射,也供 buildFormBody 按 <layout> 的 <div location> 槽位排版 +
// 隐藏未布局字段(老引擎 FormPageTemplateComponent 用 Vaadin CustomLayout,只渲染有 location
// 槽位的字段;VERSION/主键/引用 id 等无槽位 → 绑进 FieldGroup 供提交但不显示)。
Element pageRoot = null;
List<Map<String, Object>> formItems;
try {
formItems = buildFormItemsFromPage(pageId, entityId, pageResolver, result);
String pageXml = (pageResolver != null && pageId != null && !pageId.isBlank())
? pageResolver.apply(pageId) : null;
if (pageXml != null && !pageXml.isBlank()) {
pageRoot = DocumentHelper.parseText(pageXml).getRootElement();
} else {
result.degrade("tree(type=3) master-detail: 右表单 pageid=" + pageId
+ " 无法解析 view_page(缺解析器/页面不存在)→ 空字段壳");
}
formItems = buildFormItemsFromPage(pageId, entityId, pageRoot, result);
} catch (Exception e) {
result.degrade("tree(type=3) master-detail: 右表单 pageid=" + pageId
+ " 解析失败(" + e.getClass().getSimpleName() + ") → 空字段壳");
@@ -2532,7 +2782,9 @@ public class TemplateToAmisConverter {
form.put("horizontal", new LinkedHashMap<>(Map.of("left", 3, "right", 8)));
form.put("initApi", initApi);
form.put("api", "post:/api/flow/" + nb.addSvc());
form.put("body", formItems);
// 按 <layout> 的 <div location> 槽位排版 + 隐藏未布局字段(与 EDITFORM convertForm 同口径 buildFormBody):
// 修「树编辑表单泄露 VERSION/主键/引用 id 等隐藏字段 + 裸列名标签」;无 layout → buildFormBody 退两栏平铺。
form.put("body", buildFormBody(pageRoot, formItems, result));
form.put("actions", List.of(submit));
// ── 工具栏:添加(清空选中+清空表单)+ 删除(删选中节点) ──
@@ -3114,6 +3366,9 @@ public class TemplateToAmisConverter {
static final String ATTR_ON_SELECTED = "onselectedscript";
static final String ATTR_ON_LOAD = "onloadscript";
/** type=navigation 导航按钮属性:funcid 指向目标功能页(view_template_id)。 */
static final String ATTR_FUNC_ID = "funcid";
/**
* 弹窗 onloadscript marker 字段:{@link #buildFormDialog} 给 read/update 弹窗的 service body 打上
* 此标记记录按钮 onloadscript 的 scriptKey(转换器此时无 seq/rewriterDir 解析能力)。

View File

@@ -14,6 +14,7 @@ import static org.mockito.Mockito.when;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
@@ -237,6 +238,34 @@ class TemplateToAmisConverterTest {
assertEquals(true, parent.get("searchable"), "type=3 SelectDialog → tree-select 应含 searchable:true");
}
/**
* type=101 树形选择框(如「部门选择框」138b7ca7 org→部门 /「岗位选择框」feeee51d org→部门→岗位)→ tree-select。
* 此前只认 type=3,11 个 type=101 选择框被误渲扁平 picker 查到树根实体(SYS_ORG),表现「主部门/主岗位 引用不对,弹组织」。
*/
@Test
@SuppressWarnings("unchecked")
void selectDialog_type101树形选择框_treeSelect() {
JdbcTemplate jdbc = mock(JdbcTemplate.class);
lenient().when(jdbc.queryForObject(any(String.class), eq(String.class), any(Object[].class)))
.thenReturn("PM_DEMO");
lenient().when(jdbc.queryForObject(any(String.class), eq(Integer.class), any(Object[].class)))
.thenReturn(101); // dialogid=DEPTSEL → type=101 树形选择框
TemplateToAmisConverter c = new TemplateToAmisConverter(jdbc);
String xml = "<crud entityid='e1'><display/>"
+ "<search><field name='MASTERDEPART' label='主部门' uitype='SelectDialog' dialogid='DEPTSEL'/></search>"
+ "</crud>";
ConversionResult r = c.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");
Map<String, Object> dept = items.get(0);
assertEquals("tree-select", dept.get("type"), "type=101 树形选择框 → tree-select(非扁平 picker 查树根 org)");
assertEquals("/api/template/DEPTSEL/tree", dept.get("source"));
assertEquals(true, dept.get("onlyLeaf"), "type=101 选择框 → onlyLeaf 限选叶子实体(主部门只选部门)");
assertEquals(true, dept.get("searchable"), "type=101 tree-select 应含 searchable");
}
/** 不回归:dialogid 指向非树模板(type≠3)的 SelectDialog 仍转扁平 picker。 */
@Test
@SuppressWarnings("unchecked")
@@ -694,6 +723,276 @@ class TemplateToAmisConverterTest {
assertEquals(1, data.size(), "C1:业务 data 只含 PK 一个键");
}
/** type=navigation 导航按钮 → actionType=dialog + service(schemaApi=目标页) + 选中行主键默认查询注入。 */
@Test
@SuppressWarnings("unchecked")
void crud_navigation按钮转dialog并注入主键默认查询() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='navigation' name='升级历史' funcid='edbba1d9-target'"
+ " funcname='客户升级历史' isshow='true' isneedselected='true'"
+ " onloadscript='nav-script'/></crud>";
ConversionResult r = converter.convertGraded(xml, new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
// headerToolbar = [navigation-btn, pagination]
assertEquals(2, toolbar.size());
Map<String, Object> btn = (Map<String, Object>) toolbar.get(0);
assertEquals("button", btn.get("type"));
assertEquals("升级历史", btn.get("label"));
assertEquals("dialog", btn.get("actionType"));
// 需选中 → 跟随选中态启停
assertEquals("${!selectedItems || selectedItems.length === 0}", btn.get("disabledOn"));
Map<String, Object> dlg = (Map<String, Object>) btn.get("dialog");
assertEquals("dialog", dlg.get("type"));
// 标题取 funcname
assertEquals("客户升级历史", dlg.get("title"));
// dialog data 注入选中行主键(键名=源 crud 主键列),= setDefaultSearch 默认查询
Map<String, Object> data = (Map<String, Object>) dlg.get("data");
assertEquals("${selectedItems[0].PM_DEMO_ID}", data.get("PM_DEMO_ID"));
// dialog body = service 加载目标功能页 schema(schemaApi 指向 funcid)
Map<String, Object> svc = (Map<String, Object>) dlg.get("body");
assertEquals("service", svc.get("type"));
assertEquals("get:/api/page/schema/edbba1d9-target?format=amis", svc.get("schemaApi"));
}
/**
* engineclass 移植(机制①):用户管理 engineclass=UserManageView 在默认引擎页之上注入
* Java 定制按钮「设置主岗位」(弹窗 SYS_POSITIONUSER_SEARCH 列岗位单选 → SYS_POSITIONUSER_UPDATEMASTER)。
*/
@Test
@SuppressWarnings("unchecked")
void engineclass_UserManageView_注入设置主岗位按钮() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='insert' name='添加' isshow='true'><method servicename='SYS_USER_ADD'/></button></crud>";
ConversionResult r = converter.convertGraded(xml, null,
"com.dsasp.clinet.organize.view.UserManageView", "用户管理", new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
Map<String, Object> btn = toolbar.stream()
.filter(o -> o instanceof Map && "设置主岗位".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(btn, "engineclass=UserManageView 应注入「设置主岗位」按钮");
assertEquals("dialog", btn.get("actionType"));
// 恰好选中 1 条才可点
assertEquals("${!selectedItems || selectedItems.length !== 1}", btn.get("disabledOn"));
Map<String, Object> dlg = (Map<String, Object>) btn.get("dialog");
// USERID 注入弹窗数据域(选中行用户主键,默认引擎解析 mock=PM_DEMO_ID)
Map<String, Object> dlgData = (Map<String, Object>) dlg.get("data");
assertEquals("${selectedItems[0].PM_DEMO_ID}", dlgData.get("USERID"));
Map<String, Object> form = (Map<String, Object>) dlg.get("body");
assertEquals("form", form.get("type"));
// 预选现任主岗位:initApi responseData 据 ISMASTER 算 MASTERPOSITION 默认值
Map<String, Object> initApi = (Map<String, Object>) form.get("initApi");
assertEquals("/api/flow/SYS_POSITIONUSER_SEARCH", initApi.get("url"));
assertTrue(((Map<String, Object>) initApi.get("responseData")).get("MASTERPOSITION")
.toString().contains("ISMASTER"),
"initApi.responseData 应据 ISMASTER 预选主岗位");
// 单选岗位字段:source API 加载该用户岗位(引弹窗域 ${USERID})
List<Map<String, Object>> formBody = (List<Map<String, Object>>) form.get("body");
Map<String, Object> radios = formBody.stream()
.filter(f -> "MASTERPOSITION".equals(f.get("name"))).findFirst().orElse(null);
assertNotNull(radios, "应有 MASTERPOSITION 单选");
assertEquals("radios", radios.get("type"));
Map<String, Object> source = (Map<String, Object>) radios.get("source");
assertEquals("/api/flow/SYS_POSITIONUSER_SEARCH", source.get("url"));
assertEquals("${USERID}", ((Map<String, Object>) source.get("data")).get("USERID"));
// 提交设主岗位
Map<String, Object> submitApi = (Map<String, Object>) form.get("api");
assertEquals("/api/flow/SYS_POSITIONUSER_UPDATEMASTER", submitApi.get("url"));
Map<String, Object> submitData = (Map<String, Object>) submitApi.get("data");
assertEquals("${USERID}", submitData.get("USERID"));
assertEquals("${MASTERPOSITION}", submitData.get("MASTERPOSITION"));
// 同时注入「查看用户菜单」按钮 → 弹窗 input-tree 接 /api/admin/user/{userId}/menu(该用户可见菜单树)
Map<String, Object> menuBtn = toolbar.stream()
.filter(o -> o instanceof Map && "查看用户菜单".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(menuBtn, "engineclass=UserManageView 应同时注入「查看用户菜单」按钮");
Map<String, Object> menuDlg = (Map<String, Object>) menuBtn.get("dialog");
assertEquals("${selectedItems[0].PM_DEMO_ID}", ((Map<String, Object>) menuDlg.get("data")).get("USERID"));
Map<String, Object> menuTree = (Map<String, Object>) menuDlg.get("body");
assertEquals("input-tree", menuTree.get("type"));
assertEquals("/api/admin/user/${USERID}/menu",
((Map<String, Object>) menuTree.get("source")).get("url"));
}
/** engineclass=null(普通视图)不注入任何 delta 按钮(默认引擎页不变)。 */
@Test
@SuppressWarnings("unchecked")
void engineclass_null_不注入delta按钮() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='insert' name='添加' isshow='true'><method servicename='X_ADD'/></button></crud>";
ConversionResult r = converter.convertGraded(xml, null, null, "普通页", new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
boolean hasDelta = toolbar.stream()
.anyMatch(o -> o instanceof Map && "设置主岗位".equals(((Map<String, Object>) o).get("label")));
assertFalse(hasDelta, "engineclass=null 不应注入 delta 按钮");
}
/** engineclass=SystemLogMainView → 注入「通过类型删除」(LogType 弹窗)+「全部删除」(确认 ajax)。 */
@Test
@SuppressWarnings("unchecked")
void engineclass_SystemLogMainView_注入删除按钮组() {
String xml = "<crud entityid='e1'><display/></crud>";
ConversionResult r = converter.convertGraded(xml, null,
"com.dsasp.client.datadic.view.SystemLogMainView", "系统日志查询", new ArrayList<>(), noPage);
Map<String, Object> crud = body(r.getSchema());
List<Object> toolbar = (List<Object>) crud.get("headerToolbar");
// 全部删除:ajax + 二次确认 + 删全部端点(crud 内 ajax 成功 amis 自动重载,无需 reload)
Map<String, Object> all = toolbar.stream()
.filter(o -> o instanceof Map && "全部删除".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(all, "应注入「全部删除」按钮");
assertEquals("ajax", all.get("actionType"));
assertNotNull(all.get("confirmText"), "全部删除应有二次确认");
assertEquals("/api/admin/log/delete-all", ((Map<String, Object>) all.get("api")).get("url"));
// 通过类型删除:dialog + LogType 固定枚举 select + deleteByType 端点
Map<String, Object> byType = toolbar.stream()
.filter(o -> o instanceof Map && "通过类型删除".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(byType, "应注入「通过类型删除」按钮");
assertEquals("dialog", byType.get("actionType"));
Map<String, Object> form = (Map<String, Object>) ((Map<String, Object>) byType.get("dialog")).get("body");
List<Map<String, Object>> fb = (List<Map<String, Object>>) form.get("body");
Map<String, Object> sel = fb.get(0);
assertEquals("select", sel.get("type"));
assertEquals("LOGTYPE", sel.get("name"));
List<Map<String, Object>> opts = (List<Map<String, Object>>) sel.get("options");
assertEquals(4, opts.size(), "LogType 四枚举(Errors/Info/Debug/Warnings)");
assertEquals("Errors", opts.get(0).get("value"));
Map<String, Object> submitApi = (Map<String, Object>) form.get("api");
assertEquals("/api/admin/log/delete-by-type", submitApi.get("url"));
assertEquals("${LOGTYPE}", ((Map<String, Object>) submitApi.get("data")).get("type"));
}
/** engineclass=SysUserLoginHistoryMainView → 注入「根据查询条件删除记录」(读 filter USERID/LOGINTIME)。 */
@Test
@SuppressWarnings("unchecked")
void engineclass_LoginHistory_注入按条件删除按钮() {
String xml = "<crud entityid='e1'><display/></crud>";
ConversionResult r = converter.convertGraded(xml, null,
"com.dsasp.client.datadic.view.SysUserLoginHistoryMainView", "用户登录历史", new ArrayList<>(), noPage);
List<Object> toolbar = (List<Object>) body(r.getSchema()).get("headerToolbar");
Map<String, Object> btn = toolbar.stream()
.filter(o -> o instanceof Map && "根据查询条件删除记录".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(btn, "应注入「根据查询条件删除记录」按钮");
assertEquals("ajax", btn.get("actionType"));
assertNotNull(btn.get("confirmText"));
Map<String, Object> api = (Map<String, Object>) btn.get("api");
assertEquals("/api/admin/log/delete-by-logintime", api.get("url"));
Map<String, Object> data = (Map<String, Object>) api.get("data");
assertEquals("${USERID}", data.get("USERID"));
assertEquals("${LOGINTIME}", data.get("LOGINTIME"));
}
/** engineclass=SysUserLoginInfoMainView → 注入「查看登录记录」(下钻登录历史,带 USERID+OPTIMES)。 */
@Test
@SuppressWarnings("unchecked")
void engineclass_LoginInfo_注入查看登录记录下钻按钮() {
String xml = "<crud entityid='e1'><display/></crud>";
ConversionResult r = converter.convertGraded(xml, null,
"com.dsasp.client.datadic.view.SysUserLoginInfoMainView", "用户登录操作信息", new ArrayList<>(), noPage);
List<Object> toolbar = (List<Object>) body(r.getSchema()).get("headerToolbar");
Map<String, Object> btn = toolbar.stream()
.filter(o -> o instanceof Map && "查看登录记录".equals(((Map<String, Object>) o).get("label")))
.map(o -> (Map<String, Object>) o).findFirst().orElse(null);
assertNotNull(btn, "应注入「查看登录记录」按钮");
assertEquals("dialog", btn.get("actionType"));
assertEquals("${!selectedItems || selectedItems.length !== 1}", btn.get("disabledOn"));
Map<String, Object> dlg = (Map<String, Object>) btn.get("dialog");
// 下钻默认过滤:USERID=选中行主键(默认引擎 mock=PM_DEMO_ID)、LOGINTIME=本页 OPTIMES
Map<String, Object> data = (Map<String, Object>) dlg.get("data");
assertEquals("${selectedItems[0].PM_DEMO_ID}", data.get("USERID"));
assertEquals("${OPTIMES}", data.get("LOGINTIME"));
// 弹窗内嵌登录历史 schema(service schemaApi 指 edc05980)
Map<String, Object> svc = (Map<String, Object>) dlg.get("body");
assertEquals("service", svc.get("type"));
assertTrue(String.valueOf(svc.get("schemaApi")).contains("edc05980"),
"下钻应内嵌登录历史(edc05980) schema");
}
/**
* engineclass=FuncDownloadComponent(功能模板下载模板管理/设置,type=3 树页)→ 整页改写器(机制① MUTATORS):
* 移除右表单「添加」按钮(空 toolbar 整条移除)+ 右表单标题改「编辑模板附件」。复刻 refreshRightLayout。
*/
@Test
@SuppressWarnings("unchecked")
void engineclass_FuncDownload_去添加按钮并改标题() {
// 模拟转换后 type=3 树页:grid → 列[左 input-tree][右 button-toolbar[添加] + form]
Map<String, Object> addBtn = new LinkedHashMap<>();
addBtn.put("type", "button");
addBtn.put("label", "添加");
Map<String, Object> toolbar = new LinkedHashMap<>();
toolbar.put("type", "button-toolbar");
toolbar.put("buttons", new ArrayList<>(List.of(addBtn)));
Map<String, Object> form = new LinkedHashMap<>();
form.put("type", "form");
form.put("title", "功能模板下载模板设置");
Map<String, Object> rightCol = new LinkedHashMap<>();
rightCol.put("body", new ArrayList<>(List.of(toolbar, form)));
Map<String, Object> tree = new LinkedHashMap<>();
tree.put("type", "input-tree");
Map<String, Object> leftCol = new LinkedHashMap<>();
leftCol.put("body", new ArrayList<>(List.of(tree)));
Map<String, Object> grid = new LinkedHashMap<>();
grid.put("type", "grid");
grid.put("columns", new ArrayList<>(List.of(leftCol, rightCol)));
Map<String, Object> schema = new LinkedHashMap<>();
schema.put("type", "page");
schema.put("body", grid);
EngineclassDelta.apply(schema,
"com.dsasp.client.viewframework.component.FuncDownloadComponent", null);
List<Object> rb = (List<Object>) rightCol.get("body");
boolean hasToolbar = rb.stream()
.anyMatch(o -> o instanceof Map && "button-toolbar".equals(((Map<String, Object>) o).get("type")));
assertFalse(hasToolbar, "添加按钮已删 → 空 button-toolbar 应整条移除");
assertEquals("编辑模板附件", form.get("title"), "右表单标题应改为「编辑模板附件」");
// 左树不受影响、表单仍在
assertEquals("input-tree", tree.get("type"));
boolean hasForm = rb.stream()
.anyMatch(o -> o instanceof Map && "form".equals(((Map<String, Object>) o).get("type")));
assertTrue(hasForm, "右表单应保留(仅去增删按钮+改标题)");
}
/** navigation isneedselected=false → 独立导航,不注入选中行主键、按钮不随选中态禁用。 */
@Test
@SuppressWarnings("unchecked")
void crud_navigation无需选中_不注入主键不禁用() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='navigation' name='管理用户' funcid='target-func'"
+ " funcname='用户管理' isshow='true' isneedselected='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");
Map<String, Object> btn = (Map<String, Object>) toolbar.get(0);
assertEquals("dialog", btn.get("actionType"));
assertNull(btn.get("disabledOn"), "无需选中 → 不随选中态禁用");
Map<String, Object> dlg = (Map<String, Object>) btn.get("dialog");
assertNull(dlg.get("data"), "无需选中 → 不注入主键默认查询");
Map<String, Object> svc = (Map<String, Object>) dlg.get("body");
assertEquals("get:/api/page/schema/target-func?format=amis", svc.get("schemaApi"));
}
/** navigation 缺 funcid → 诚实降级为提示 tpl,不产出指向空目标的 service。 */
@Test
@SuppressWarnings("unchecked")
void crud_navigation缺funcid降级提示() {
String xml = "<crud entityid='e1'><display/>"
+ "<button type='navigation' name='坏导航' isshow='true' isneedselected='true'/></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(0);
assertEquals("dialog", btn.get("actionType"));
Map<String, Object> dlg = (Map<String, Object>) btn.get("dialog");
Map<String, Object> tpl = (Map<String, Object>) dlg.get("body");
assertEquals("tpl", tpl.get("type"));
}
@Test
void crud_isshowFalse按钮跳过() {
String xml = "<crud entityid='e1'><display/>"
@@ -1302,12 +1601,11 @@ class TemplateToAmisConverterTest {
assertEquals("submit", submit.get("type"));
assertEquals("保存", submit.get("label"));
// form.body:UiTypeMapper 忠实字段——TYPENAME=input-text,MENUROOT(SelectDialog+dialogid)=picker
List<Map<String, Object>> formItems = (List<Map<String, Object>>) form.get("body");
// form.body:经 buildFormBody 按 <layout> 排版(本 mock 无 <layout> → buildFormRows 两栏分组),
// 字段被包进行组容器,故递归收集字段名→type。UiTypeMapper 忠实字段——TYPENAME=input-text,
// MENUROOT(SelectDialog+dialogid)=picker。
Map<String, Object> byName = new java.util.HashMap<>();
for (Map<String, Object> it : formItems) {
byName.put(String.valueOf(it.get("name")), it.get("type"));
}
collectFieldTypes(form.get("body"), byName);
assertEquals("input-text", byName.get("TYPENAME"), "TextField → input-text");
assertEquals("picker", byName.get("MENUROOT"), "SelectDialog+dialogid → picker(弹出框)");
// 注:grid 列 body 用数组(多子节点)= 严格对齐 menu v5 bespoke(sys_page_schema 直存形态,
@@ -1315,6 +1613,26 @@ class TemplateToAmisConverterTest {
// bespoke 本身亦不过严格闸一,故此处不挂 SchemaGate 断言(保持与 live 一致)。
}
/** 递归收集表单 body 里所有带 name+type 的字段项 → {name: type}(穿透 buildFormBody 的 group/grid/tabs 容器)。 */
@SuppressWarnings("unchecked")
private static void collectFieldTypes(Object node, Map<String, Object> out) {
if (node instanceof Map) {
Map<String, Object> m = (Map<String, Object>) node;
Object name = m.get("name");
Object type = m.get("type");
if (name != null && type instanceof String && !"form".equals(type)) {
out.putIfAbsent(String.valueOf(name), type);
}
for (Object v : m.values()) {
collectFieldTypes(v, out);
}
} else if (node instanceof List) {
for (Object x : (List<Object>) node) {
collectFieldTypes(x, out);
}
}
}
/**
* 菜单维护:一棵 tree 含多个 &lt;node&gt;——可编辑数据节点(edit=true + pageid)+ 纯根节点
* (isroot=true edit=false selectservice,无 pageid)。须选可编辑节点作 master-detail 数据节点,
@@ -2898,6 +3216,124 @@ class TemplateToAmisConverterTest {
assertEquals("input-password", items.get(1).get("type")); // A0 控件在编辑表单迁移路径同生效
}
@Test
@SuppressWarnings("unchecked")
void viewPage_filterscript级联_组织过滤部门_部门过滤岗位() {
// 用户添加表单(71de2065)的真实级联:MASTERDEPART 按 USERORGID 过滤、MASTERPOSITION 按 MASTERDEPART 过滤。
// 字段 filterscript 指向的脚本体 searchMap.put("COL", getFieldValue("TRIGGER")) → 把 &COL=${TRIGGER}
// 追加进该字段 source;amis 对含 ${var} 的 source 自动监听重拉(与树 node=${tree} 同机制),
// 组织→部门→岗位级联即成(P1,无需 onEvent)。
String pageXml = "<page entityid='e1'><fields>"
+ "<field name='USERORGID' label='组织' uitype='SelectDialog' dialogid='ORG1'/>"
+ "<field name='MASTERDEPART' label='部门' uitype='ComboBox'"
+ " comboboxitemservice='SYS_DEPART_SEARCH' filterscript='SK1'/>"
+ "<field name='MASTERPOSITION' label='岗位' uitype='ComboBox'"
+ " comboboxitemservice='SYS_POSITION_SEARCH' filterscript='SK2'/>"
+ "</fields>"
+ "<scripts>"
+ "<script key='SK1' name='根据组织过滤部门'>"
+ "def searchMap = [:]; searchMap.put(\"PARENTORGID\", getFieldValue(\"USERORGID\")); "
+ "group.getField(\"MASTERDEPART\").setFilter(searchMap);"
+ "</script>"
+ "<script key='SK2' name='根据部门过滤岗位'>"
+ "def searchMap = [:]; searchMap.put(\"PARENTDEPARTID\", getFieldValue(\"MASTERDEPART\")); "
+ "group.getField(\"MASTERPOSITION\").setFilter(searchMap);"
+ "</script>"
+ "</scripts></page>";
ConversionResult r = converter.convertGraded(pageXml, "用户添加表单", new ArrayList<>(), noPage);
assertEquals("page", r.getRootElement());
List<Map<String, Object>> items = flattenFormBody(body(r.getSchema()));
Map<String, Map<String, Object>> byName = new java.util.HashMap<>();
for (Map<String, Object> it : items) {
byName.put(String.valueOf(it.get("name")), it);
}
// 部门 source 追加按组织过滤参 → amis 监听 ${USERORGID} 变化重拉
assertEquals("/api/picker/SYS_DEPART/list?perPage=500&PARENTORGID=${USERORGID}",
byName.get("MASTERDEPART").get("source"));
// 岗位 source 追加按部门过滤参 → 级联第二跳
assertEquals("/api/picker/SYS_POSITION/list?perPage=500&PARENTDEPARTID=${MASTERDEPART}",
byName.get("MASTERPOSITION").get("source"));
// 性能:触发字段为空时不预拉(避免表单打开即发空参全量请求)。initFetchOn=触发字段表达式,
// 选了组织才拉部门、选了部门才拉岗位;编辑态触发字段有值则照常初拉。
assertEquals("${USERORGID}", byName.get("MASTERDEPART").get("initFetchOn"));
assertEquals("${MASTERDEPART}", byName.get("MASTERPOSITION").get("initFetchOn"));
}
@Test
@SuppressWarnings("unchecked")
void viewPage_filterscript_bracket语法动态级联() {
// ③ 变体:map["COL"] = getFieldValue("TRIG") 方括号赋值(非 .put)也识别为级联。
String pageXml = "<page entityid='e1'><fields>"
+ "<field name='ORGID' label='组织' uitype='SelectDialog' dialogid='ORG1'/>"
+ "<field name='DEPT' label='部门' uitype='ComboBox'"
+ " comboboxitemservice='SYS_DEPART_SEARCH' filterscript='SK'/>"
+ "</fields>"
+ "<scripts>"
+ "<script key='SK' name='过滤部门'>def map=[:]; map[\"PARENTORGID\"] = getFieldValue(\"ORGID\"); "
+ "group.getField(\"DEPT\").setFilter(map);</script>"
+ "</scripts></page>";
ConversionResult r = converter.convertGraded(pageXml, "bracket级联", new ArrayList<>(), noPage);
List<Map<String, Object>> items = flattenFormBody(body(r.getSchema()));
assertEquals("/api/picker/SYS_DEPART/list?perPage=500&PARENTORGID=${ORGID}", items.get(1).get("source"));
assertEquals("${ORGID}", items.get(1).get("initFetchOn"));
}
@Test
@SuppressWarnings("unchecked")
void viewPage_filterscript_常量固化() {
// ⑦ 常量过滤:searchMap.put("STATUS", 3) 固定值 → source 加 &STATUS=3(不设 initFetchOn,常量恒生效)。
String pageXml = "<page entityid='e1'><fields>"
+ "<field name='X' label='下拉' uitype='ComboBox'"
+ " comboboxitemservice='SYS_DEPART_SEARCH' filterscript='SK'/>"
+ "</fields>"
+ "<scripts>"
+ "<script key='SK' name='常量过滤'>def searchMap=[:]; searchMap.put(\"STATUS\", 3); "
+ "group.getField(\"X\").setFilter(searchMap);</script>"
+ "</scripts></page>";
ConversionResult r = converter.convertGraded(pageXml, "常量过滤", new ArrayList<>(), noPage);
List<Map<String, Object>> items = flattenFormBody(body(r.getSchema()));
assertEquals("/api/picker/SYS_DEPART/list?perPage=500&STATUS=3", items.get(0).get("source"));
assertNull(items.get(0).get("initFetchOn"), "纯常量无触发字段 → 不设 initFetchOn(恒初拉)");
}
@Test
@SuppressWarnings("unchecked")
void viewPage_filterscript_含SQL护栏整条跳过() {
// 正确性护栏:脚本含原始 SQL / CustomSearchConditional / 服务调用 / 控制流 → 整条不译,
// source 保持原样(绝不"只搬一半"导致少过滤显多余数据)。即便其中有可识别的简单 put 也跳过。
String pageXml = "<page entityid='e1'><fields>"
+ "<field name='Y' label='下拉' uitype='ComboBox'"
+ " comboboxitemservice='SYS_DEPART_SEARCH' filterscript='SK'/>"
+ "</fields>"
+ "<scripts>"
+ "<script key='SK' name='复杂过滤'>import com.dsasp.server.common.dataDic.bean.CustomSearchConditional; "
+ "def searchMap=[:]; searchMap.put(\"PARENTORGID\", getFieldValue(\"Z\")); "
+ "def sql = \" Y_ID NOT IN (SELECT id FROM T) \"; searchMap.put(\"WhereClause\", sql);"
+ "group.getField(\"Y\").setFilter(searchMap);</script>"
+ "</scripts></page>";
ConversionResult r = converter.convertGraded(pageXml, "复杂过滤2", new ArrayList<>(), noPage);
List<Map<String, Object>> items = flattenFormBody(body(r.getSchema()));
assertEquals("/api/picker/SYS_DEPART/list?perPage=500", items.get(0).get("source"), "含SQL→整条跳过,source不变");
assertNull(items.get(0).get("initFetchOn"));
}
@Test
@SuppressWarnings("unchecked")
void viewPage_filterscript无getFieldValue模式_不改source() {
// filterscript 存在但非「searchMap.put(COL, getFieldValue(TRIGGER))」模式(如纯常量过滤/复杂脚本)→
// 转换器不臆造级联参,保持 source 原样(P3 通用脚本兜底另案,不在 P1 改动)。
String pageXml = "<page entityid='e1'><fields>"
+ "<field name='MASTERDEPART' label='部门' uitype='ComboBox'"
+ " comboboxitemservice='SYS_DEPART_SEARCH' filterscript='SK1'/>"
+ "</fields>"
+ "<scripts>"
+ "<script key='SK1' name='复杂过滤'>def x = doSomething(); applyComplexFilter(x);</script>"
+ "</scripts></page>";
ConversionResult r = converter.convertGraded(pageXml, "复杂过滤表单", new ArrayList<>(), noPage);
List<Map<String, Object>> items = flattenFormBody(body(r.getSchema()));
assertEquals("/api/picker/SYS_DEPART/list?perPage=500", items.get(0).get("source"));
}
@Test
@SuppressWarnings("unchecked")
void a3_resolveEditForm无type7包壳但viewPage存在_直接命中pageId() {

View File

@@ -106,6 +106,57 @@ public class FlowInputCoercer {
applyCoerce(map, colTypes);
}
/**
* 读流(SEARCH)日期 coerce:<b>仅</b>把 DATE/TIME 列的 String 值转 {@code DateTime}/{@code DateTime[]}。
*
* <p>amis {@code input-date(time)-range} 把时间段提交为 "起,止" 逗号串,但引擎 GeneralPO 的搜索 where
* 构建只对 {@code DateTime[]} 值生成区间条件 {@code (col>=起 AND col<=止)}——收到 String 则识别不了,
* 整条时间段过滤被忽略(操作日志等"时间段查不动"根因)。本方法把日期列值转成引擎期望形态。
*
* <p><b>只碰 DATE/TIME 列</b>,其它过滤参(文本/枚举/picker)一概不动 → 对已工作的搜索零回归。fail-safe:
* 无表名/查元数据失败/parse 失败 → 原值保留。供 {@code FlowController} 命名读流(NAMED_READ)路径调用。
*/
public void coerceSearchDatesByFlowId(String flowId, Map<String, Object> map) {
if (flowId == null || flowId.isBlank() || map == null || map.isEmpty()) {
return;
}
coerceDatesOnly(map, flowTableCache.get(flowId, this::resolveTableNameByFlowId));
}
/**
* 同 {@link #coerceSearchDatesByFlowId},但表名直接给定——合成 {@code _SEARCH} 流无 contentxml,
* 表名由 key 剥后缀推得({@code FlowController} SYNTHESIZED 路径用)。
*/
public void coerceSearchDatesByTable(String tableName, Map<String, Object> map) {
if (map == null || map.isEmpty()) {
return;
}
coerceDatesOnly(map, tableName);
}
/** 就地:只对 {@code tableName} 里 DATE/TIME 列的 String 值做日期/区间 coerce,其余键不动。 */
private void coerceDatesOnly(Map<String, Object> map, String tableName) {
if (tableName == null || tableName.isEmpty()) {
return;
}
Map<String, String> colTypes = columnTypeCache.get(tableName, this::queryColumnTypes);
if (colTypes.isEmpty()) {
return;
}
for (Map.Entry<String, Object> entry : map.entrySet()) {
if (!(entry.getValue() instanceof String s) || s.isEmpty()) {
continue;
}
String refId = colTypes.get(entry.getKey().toUpperCase());
if ("DATE".equals(refId) || "TIME".equals(refId)) {
Object coerced = coerceValue(s, refId, entry.getKey());
if (coerced != entry.getValue()) {
entry.setValue(coerced);
}
}
}
}
/**
* 就地 coerce 写流入参 map:按流 contentxml 里的 tableName 查元数据,把 String 值
* 强制转成引擎期望的 Java 类型(Integer/Boolean/BigDecimal),其余类型不动。
@@ -426,7 +477,9 @@ public class FlowInputCoercer {
// DATE/TIME 列:引擎 GeneralPO 期望 joda DateTime,amis input-date/datetime 提交字符串
// (ISO/时间戳/yyyy-MM-dd[ HH:mm:ss])。原默认不转 → 引擎直接 cast String→DateTime 抛
// ClassCastException,致一切含日期列的表单写流崩。此处 String→joda DateTime(parse 失败保留原值)。
return coerceDate(val.trim(), colName);
// amis input-date(time)-range 提交 "起,止"(逗号串) → joda DateTime[],引擎 GeneralPO 据此
// 构建区间查询 (col>=起millis AND col<=止millis);单值 → DateTime。
return coerceDateMaybeRange(val.trim(), colName);
}
default -> {
// NVARCHAR/CHAR/LIST/BLOB/CODE/UUID-ref 等 → 不动
@@ -435,12 +488,44 @@ public class FlowInputCoercer {
}
}
/** DATE/TIME 字符串 → joda {@link DateTime}:依次试 毫秒时间戳 → ISO → {@code yyyy-MM-dd HH:mm:ss} → {@code yyyy-MM-dd};都失败保留原值。 */
/**
* DATE/TIME 值 coerce,识别 amis 区间:"起,止"(逗号串) → {@code DateTime[]}(引擎 GeneralPO 构建
* {@code (col>=起 AND col<=止)} 区间查询);单值 → {@code DateTime}。空段 → null(引擎该侧不加约束);
* 两段都解析失败 → 原 String 保留(fail-safe)。
*/
private Object coerceDateMaybeRange(String v, String colName) {
if (v.isEmpty()) {
return v;
}
int comma = v.indexOf(',');
if (comma < 0) {
return coerceDate(v, colName); // 单值
}
String startStr = v.substring(0, comma).trim();
String endStr = v.substring(comma + 1).trim();
Object start = startStr.isEmpty() ? null : coerceDate(startStr, colName);
Object end = endStr.isEmpty() ? null : coerceDate(endStr, colName);
boolean startOk = start == null || start instanceof DateTime;
boolean endOk = end == null || end instanceof DateTime;
if (startOk && endOk && (start != null || end != null)) {
return new DateTime[] { (DateTime) start, (DateTime) end };
}
return v; // 解析失败 → 保留原值
}
/** DATE/TIME 字符串 → joda {@link DateTime}:依次试 秒/毫秒时间戳 → ISO → {@code yyyy-MM-dd HH:mm:ss} → {@code yyyy-MM-dd};都失败保留原值。 */
private Object coerceDate(String v, String colName) {
if (v.isEmpty()) {
return v;
}
if (v.matches("-?\\d{12,}")) { // 13 位左右毫秒时间戳
if (v.matches("-?\\d{10,11}")) { // 10-11 位 → unix 秒(amis input-date(time)-range 默认 format=X)
try {
return new DateTime(Long.parseLong(v) * 1000L);
} catch (RuntimeException ignore) {
// 继续试
}
}
if (v.matches("-?\\d{12,}")) { // 12+ 位 → 毫秒时间戳
try {
return new DateTime(Long.parseLong(v));
} catch (RuntimeException ignore) {

View File

@@ -291,6 +291,11 @@ public class FlowController {
// 命名读流:GET/POST 皆可。WS-D D.3:命名读流(如查看新闻查询 OA_NEWSMANAGE_SEARCH_LOOK)按其
// sys_serviceflow.entityid → sys_entity.tablename 解析数据源实体表,使引用列 id→姓名解析生效
// (发布人 USERSEND_ID 等显「-」根因);解析不到 → null,跳过解析(现状行为不变)。
// 时间段过滤:amis input-date(time)-range 提交 "起,止" 逗号串,引擎需 DateTime[] 才构建区间
// 查询。仅转 DATE/TIME 列(其它过滤参不动,零回归),修「操作日志等时间段查不动」。
if (inputCoercer != null) {
inputCoercer.coerceSearchDatesByFlowId(id, map);
}
Properties ctx = UserSession.getAdmin();
Object output = flowExcuteService.excute(map, ctx, id);
yield ok(output, flowNameResolver.entityTableForNamedFlow(id));
@@ -343,6 +348,10 @@ public class FlowController {
// 直接用原始 flowId(已大写 = TABLE_SEARCH)调引擎。读流,GET/POST 皆可。
Properties ctx = UserSession.getAdmin();
String flowKey = resolved.definition().getKey();
// 时间段过滤同 NAMED_READ:合成流无 contentxml,表名由 key 剥 _SEARCH 后缀得(仅转 DATE/TIME 列)。
if (inputCoercer != null) {
inputCoercer.coerceSearchDatesByTable(tableFromSearchKey(flowKey), map);
}
Object output = flowExcuteService.excute(map, ctx, flowKey);
// 合成搜索流的 key = <TABLE>_SEARCH,剥后缀即数据源实体表名,用于用户引用列 id→姓名解析
yield ok(output, tableFromSearchKey(flowKey));

View File

@@ -0,0 +1,168 @@
package com.eip4.platform.metadata.web;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.joda.time.DateTime;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.dsasp.server.common.log.service.SystemLogManager;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
* 系统日志删除端点(移植 engineclass {@code SystemLogMainView} 的删除按钮 delta)。
*
* <p>老系统 {@code SystemLogMainView.bindingDataView} 在默认日志列表页之上加两个按钮:
* <ul>
* <li>「通过类型删除」:弹窗选 {@code SystemLogManager.LogType}(Errors/Info/Debug/Warnings)→
* {@code systemLogManager.deleteByType(value)};</li>
* <li>「全部删除」:{@code systemLogManager.deleteAll()}。</li>
* </ul>
* 转换器机制① {@code EngineclassDelta} 注入对应工具栏按钮,按钮 ajax 调本端点。
*
* <p>{@code systemLogManager} 是 platform-legacy-core 的真实现 bean({@code @Service("systemLogManager")},
* 与老引擎方法签名一致),构造器注入。鉴权沿用 SecurityFilterChain(JWT),与 {@link MenuController} 同惯例。
*
* <p>返回 amis 动作契约 {@code {status:0,msg:""}}(status=0 成功,amis 据此 toast + crud 自动重载)。
*/
@Tag(name = "系统日志删除", description = "移植 SystemLogMainView 删除 delta(全部删除 / 按类型删除)")
@RestController
@RequestMapping("/api/admin/log")
public class LogController {
private final SystemLogManager systemLogManager;
public LogController(SystemLogManager systemLogManager) {
this.systemLogManager = systemLogManager;
}
/** 全部删除系统日志(移植 SystemLogMainView.deleteAll)。 */
@Operation(summary = "删除全部系统日志")
@PostMapping("/delete-all")
public Map<String, Object> deleteAll() {
systemLogManager.deleteAll();
return ok();
}
/**
* 按日志类型删除(移植 SystemLogMainView.deleteByType)。
* {@code type} 取 {@code SystemLogManager.LogType} 的 value(Errors/Info/Debug/Warnings);
* 兼容查询参或 JSON body(amis ajax 默认 JSON body {@code {type:...}})。空类型 → 不删除(防误清全部)。
*/
@Operation(summary = "按类型删除系统日志")
@PostMapping("/delete-by-type")
public Map<String, Object> deleteByType(@RequestParam(required = false) String type,
@RequestBody(required = false) Map<String, Object> body) {
String t = (type != null && !type.isBlank())
? type
: (body != null && body.get("type") != null ? String.valueOf(body.get("type")) : null);
if (t == null || t.isBlank()) {
// 空类型不下推删除(避免退化成删全部);返回成功但无操作
return ok();
}
// 安全白名单:仅允许 LogType 枚举值(Errors/Info/Debug/Warnings)。底层实现是字符串拼接
// (DELETE FROM SYS_LOG WHERE TYPE='<t>'),不白名单则已认证用户可经 type 注入 → 此处用枚举闸住。
if (SystemLogManager.LogType.getType(t.trim()) == null) {
return ok(); // 非 LogType 枚举值 → 拒绝(不删除)
}
systemLogManager.deleteByType(t.trim());
return ok();
}
/**
* 按登录历史查询条件删除(移植 SysUserLoginHistoryMainView.deleteRecord → systemLogManager
* .deleteByLoginTime(userIds, loginTimes))。读 amis crud filter 的 {@code USERID}(多选 picker,
* 逗号串 _id)+ {@code LOGINTIME}(datetime-range,amis 默认 valueFormat=X 秒,值 "起,止")。
*
* <p>底层 impl:{@code DELETE FROM SYS_USERLOGIN_HISTORY WHERE 1=1 [AND USERID IN(...)]
* [AND LOGINTIME >= / <= millis]}。<b>无任何条件 → 删除全部</b>(与老引擎一致;前端按钮带二次确认)。
* USERID 经 {@code StringUtil.TO_STRING} 引号转义进 IN(杜绝注入),LOGINTIME 取毫秒数值。
*/
@Operation(summary = "按查询条件删除登录历史")
@PostMapping("/delete-by-logintime")
public Map<String, Object> deleteByLoginTime(@RequestBody(required = false) Map<String, Object> body) {
List<String> userIds = body == null ? new ArrayList<>() : parseIds(body.get("USERID"));
DateTime[] times = body == null ? null : parseRange(body.get("LOGINTIME"));
systemLogManager.deleteByLoginTime(userIds.isEmpty() ? null : userIds, times);
return ok();
}
/** 解析 USERID:逗号串 / 数组 → List&lt;String&gt;(trim + 去空)。 */
private static List<String> parseIds(Object v) {
List<String> ids = new ArrayList<>();
if (v == null) {
return ids;
}
if (v instanceof List<?> list) {
for (Object o : list) {
if (o != null && !String.valueOf(o).isBlank()) {
ids.add(String.valueOf(o).trim());
}
}
} else {
for (String p : String.valueOf(v).split(",")) {
if (!p.isBlank()) {
ids.add(p.trim());
}
}
}
return ids;
}
/** 解析 datetime-range:字符串 "起,止" / 数组 → {@code DateTime[2]}(秒/毫秒自适应)。全空 → null(不加时间条件)。 */
private static DateTime[] parseRange(Object v) {
if (v == null) {
return null;
}
String s = String.valueOf(v).trim();
if (s.isEmpty()) {
return null;
}
String[] parts = s.split(",");
DateTime start = parts.length > 0 ? toDateTime(parts[0]) : null;
DateTime end = parts.length > 1 ? toDateTime(parts[1]) : null;
if (start == null && end == null) {
return null;
}
return new DateTime[]{start, end};
}
/** 数值时间戳 → DateTime:&lt;1e11 视为秒(×1000),否则毫秒;非数值兜底按 ISO 解析;失败 null。 */
private static DateTime toDateTime(String x) {
if (x == null) {
return null;
}
x = x.trim();
if (x.isEmpty()) {
return null;
}
try {
long n = Long.parseLong(x);
if (n < 100_000_000_000L) { // 10 位秒 < 1e11 < 13 位毫秒 → 秒转毫秒
n *= 1000L;
}
return new DateTime(n);
} catch (NumberFormatException e) {
try {
return new DateTime(x); // ISO 日期字符串兜底
} catch (RuntimeException ex) {
return null;
}
}
}
private static Map<String, Object> ok() {
Map<String, Object> m = new HashMap<>();
m.put("status", 0);
m.put("msg", "");
return m;
}
}

View File

@@ -9,6 +9,7 @@ import java.util.stream.Collectors;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import com.dsasp.server.common.user.service.LoggedInUser;
@@ -62,6 +63,28 @@ public class MenuController {
return emptyRoots();
}
return menuTreeFor(userId);
}
/**
* 「查看用户菜单」(移植 UserManageView.buildUserRoleBtn / UserRoleView):返回**指定用户**可见的菜单树,
* 裁剪依据 view_sys_usermenuid(userid=该用户),与 {@link #menu()} 同一棵树构建逻辑(仅用户来源不同)。
*
* @param userId 目标用户 SYS_USER_ID(用户管理列表选中行主键)
* @return {@code { roots: [...] }};空/无菜单返回空 roots
*/
@Operation(summary = "指定用户可见菜单树(查看用户菜单)",
description = "裁剪依据:view_sys_usermenuid(userid=指定用户);移植自老 UserRoleView")
@GetMapping("/api/admin/user/{userId}/menu")
public Map<String, Object> userMenu(@PathVariable String userId) {
if (userId == null || userId.isBlank()) {
return emptyRoots();
}
return menuTreeFor(userId.trim());
}
/** 按给定 userId 构建按权限裁剪的菜单树({@link #menu()} 与 {@link #userMenu} 共用)。 */
private Map<String, Object> menuTreeFor(String userId) {
// 2. 查询 root 列表(全量 isactive=1,按 seq 排序)
List<Map<String, Object>> roots = jdbcTemplate.query(
"SELECT trim(sys_menu_root_id) AS id, trim(name) AS name, seq"
@@ -97,10 +120,10 @@ public class MenuController {
return m;
});
// 4. 计算当前用户可见叶子菜单 id 集合
// 4. 计算该用户可见叶子菜单 id 集合
// 超管(ADMIN):bypass 裁剪,可见集 = 全部 isactive 叶子菜单(与老框架
// ViewMenuServiceImpl 一致——admin 不 JOIN view_sys_usermenuid,见全部菜单)。
// 普通用户:按 view_sys_usermenuid(userid=当前用户) 裁剪。
// 普通用户:按 view_sys_usermenuid(userid=该用户) 裁剪。
Set<String> visibleMenuIds;
if (isAdmin(userId)) {
visibleMenuIds = MenuService.allLeafMenuIds(menus);

View File

@@ -27,6 +27,7 @@ import com.dsasp.server.common.exception.PrivilegeException;
import com.dsasp.server.common.user.service.LoggedInUser;
import com.dsasp.server.common.util.UserSession;
import com.dsasp.server.dataDic.bean.POInfo;
import com.eip4.platform.metadata.flow.UserColumnResolver;
import com.eip4.platform.metadata.security.IdentifierWhitelist;
import com.eip4.platform.metadata.security.IllegalIdentifierException;
@@ -72,15 +73,19 @@ public class PickerController {
private final DataDicService dataDicService;
private final IdentifierWhitelist identifierWhitelist;
private final JdbcTemplate jdbcTemplate;
/** 与功能列表(FlowController)同一套引用列显名解析——picker 行也补 {COL}_DISPLAY__,列改指显名。 */
private final UserColumnResolver userColumnResolver;
public PickerController(POJOCRUDService pojoCRUDService,
DataDicService dataDicService,
IdentifierWhitelist identifierWhitelist,
JdbcTemplate jdbcTemplate) {
JdbcTemplate jdbcTemplate,
UserColumnResolver userColumnResolver) {
this.pojoCRUDService = pojoCRUDService;
this.dataDicService = dataDicService;
this.identifierWhitelist = identifierWhitelist;
this.jdbcTemplate = jdbcTemplate;
this.userColumnResolver = userColumnResolver;
}
/**
@@ -176,6 +181,12 @@ public class PickerController {
if (q != null && !q.isBlank() && labelColumn != null) {
cond.put(labelColumn, escapeLikeValue(q.trim()));
}
// filterscript 级联过滤(组织→部门→岗位等):转换器把字段 filterscript 的 setFilter 语义译成
// source 上的 &FILTERCOL=${TRIGGER} 查询参(见 TemplateToAmisConverter.applyFilterscriptCascade)。
// 这里把 allParams 里「命中本表真实列名」的非空参作等值条件下推(值经 escapeLikeValue 转义;引擎对
// String 条件走 col like '%值%',恰好匹配 CHAR(36) 主键的尾空格补白值)。非表列/控制参/空值一律忽略
// ——表列名匹配本身即白名单,杜绝任意列注入;空值不下推(amis 触发器未选时列出全部,不致误清空)。
applyColumnFilters(cond, info, allParams);
Map<String, Object> result;
try {
@@ -195,6 +206,9 @@ public class PickerController {
}
List<Map<String, Object>> rows = toRows(result.get(POJOCRUDService.LIST_RESULT));
// 统一引用列解析:与功能列表(FlowController.executePost → userColumnResolver.resolveRows)完全同一套,
// 给每行补 {COL}_DISPLAY__(如 PARENTID→父组织名/DEPARTID→部门名),修「picker 列父级组织等显裸 id」。
userColumnResolver.resolveRows(table, rows);
List<Map<String, Object>> options = new ArrayList<>();
for (Map<String, Object> row : rows) {
Object rowId = row.get("_id");
@@ -213,12 +227,17 @@ public class PickerController {
// 选择窗多列:优先用 dialog(view_template)<display> 里显式声明的列(忠实复刻老系统弹窗列序,
// 如用品选择「用品类别/用品名称/规格/单位/重要性/库存数量」);无模板 display(孤儿模板/直连实体)
// 才回落实体元数据启发式 gridColumns。修「多选弹窗列不对(仅显 名称+裸类别 id)」。
List<Map<String, Object>> displayCols = displayColumnsFromTemplate(entityOrRef);
List<Map<String, Object>> cols = displayColumnsFromTemplate(entityOrRef);
if (cols == null) {
cols = gridColumns(table, info, keyColumn, labelColumn);
}
// 引用列改指显名:列 name=PARENTID 且行已补 PARENTID_DISPLAY__ → 列 name 改 PARENTID_DISPLAY__,
// amis 按 name 取行字段 → 显父组织名而非裸 id(label 保留)。与功能列表(FlowController)同口径。
remapReferenceColumnsToDisplay(cols, rows);
Map<String, Object> data = new HashMap<>();
data.put("items", rows); // amis crud/picker 内嵌 CRUD 直接消费
data.put("options", options); // amis select 的 source 直接消费
data.put("columns", displayCols != null ? displayCols
: gridColumns(table, info, keyColumn, labelColumn)); // amis picker 内嵌 CRUD 按响应 columns 渲染多列
data.put("columns", cols); // amis picker 内嵌 CRUD 按响应 columns 渲染多列
data.put("total", result.get(POJOCRUDService.PAGE_COUNT));
Map<String, Object> resp = new HashMap<>();
@@ -228,6 +247,71 @@ public class PickerController {
return resp;
}
/**
* 引用列改指显名:对每个列,若其 {@code name=COL} 且行内已补 {@code COL_DISPLAY__}(由
* {@link UserColumnResolver#resolveRows} 填),把列 {@code name} 改为 {@code COL_DISPLAY__}
* → amis 按 name 取行字段渲染,显引用对象名(如父组织名/部门名)而非裸 id,列 {@code label} 不变。
* 与功能列表(FlowController)的引用列显名口径一致。空列/空行 → no-op。
*/
private static void remapReferenceColumnsToDisplay(List<Map<String, Object>> cols,
List<Map<String, Object>> rows) {
if (cols == null || cols.isEmpty() || rows == null || rows.isEmpty()) {
return;
}
Map<String, Object> sample = rows.get(0);
for (Map<String, Object> col : cols) {
Object nameObj = col.get("name");
if (!(nameObj instanceof String name) || name.isBlank() || name.endsWith("_DISPLAY__")) {
continue;
}
if (sample.containsKey(name + "_DISPLAY__")) {
col.put("name", name + "_DISPLAY__");
}
}
}
/** {@link #list} 的控制参(非过滤列):这些键即便撞上表列名也不作过滤条件。 */
private static final java.util.Set<String> LIST_CONTROL_PARAMS = java.util.Set.of(
"Q", "PAGE", "PERPAGE", "OP", "VALUE", "_ID",
"ASUSER", "ROLES", "ASDEPART", "ASORG");
/**
* filterscript 级联列过滤:把 {@code allParams} 里「命中本表真实列名(大小写不敏感)且非控制参、非空值」
* 的参作等值条件加进 {@code cond}(值经 {@link #escapeLikeValue} 转义)。表列名匹配本身即白名单——
* 任意非列参(amis 内部参/未知参)天然被忽略,杜绝任意列注入。空值参不下推(amis 级联触发器未选时
* 不致把列表误清空,而是列出全部,与级联渐进收窄的 UX 一致)。
*/
private void applyColumnFilters(Map<String, Object> cond, POJOInfo info,
MultiValueMap<String, String> allParams) {
if (cond == null || info == null || allParams == null || allParams.isEmpty()) {
return;
}
// 本表真实列名集合(大写)——级联过滤的白名单
java.util.Set<String> columns = new java.util.HashSet<>();
for (int i = 0; i < info.getColumnCount(); i++) {
String c = info.getColumnName(i);
if (c != null && !c.isBlank()) {
columns.add(c.toUpperCase());
}
}
for (Map.Entry<String, List<String>> e : allParams.entrySet()) {
String key = e.getKey();
if (key == null || key.isBlank()) {
continue;
}
String keyUp = key.toUpperCase();
if (LIST_CONTROL_PARAMS.contains(keyUp) || !columns.contains(keyUp)) {
continue; // 控制参 / 非本表列 → 忽略
}
List<String> vals = e.getValue();
String v = (vals == null || vals.isEmpty()) ? null : vals.get(0);
if (v == null || v.isBlank()) {
continue; // 空值(触发器未选)→ 不下推,列出全部
}
cond.put(keyUp, escapeLikeValue(v.trim()));
}
}
/**
* 选择窗回显解析:{@code GET /api/picker/{entityOrRef}/resolve?value=}。
*

View File

@@ -187,6 +187,60 @@ class FlowInputCoercerTest {
assertEquals("maybe", result);
}
// ── coerceValue DATE/TIME(单值 + amis 区间 input-date(time)-range)──────────
@Test
@DisplayName("coerceValue: TIME 'yyyy-MM-dd HH:mm:ss' → joda DateTime")
void coerceTimeFormatted() {
Object r = coercer.coerceValue("2026-06-15 17:41:00", "TIME", "UPDATETIME");
org.junit.jupiter.api.Assertions.assertInstanceOf(org.joda.time.DateTime.class, r);
}
@Test
@DisplayName("coerceValue: TIME unix 秒(10位) → DateTime(×1000,amis range 默认 format=X)")
void coerceTimeUnixSeconds() {
Object r = coercer.coerceValue("1749978060", "TIME", "UPDATETIME");
org.junit.jupiter.api.Assertions.assertInstanceOf(org.joda.time.DateTime.class, r);
assertEquals(1749978060_000L, ((org.joda.time.DateTime) r).getMillis(), "秒应 ×1000 转毫秒");
}
@Test
@DisplayName("coerceValue: TIME 区间 '起秒,止秒' → DateTime[](引擎据此构建区间查询)")
void coerceTimeRangeSeconds() {
Object r = coercer.coerceValue("1749978060,1750237260", "TIME", "UPDATETIME");
org.junit.jupiter.api.Assertions.assertInstanceOf(org.joda.time.DateTime[].class, r);
org.joda.time.DateTime[] arr = (org.joda.time.DateTime[]) r;
assertEquals(2, arr.length);
assertEquals(1749978060_000L, arr[0].getMillis());
assertEquals(1750237260_000L, arr[1].getMillis());
}
@Test
@DisplayName("coerceValue: TIME 区间格式化字符串 '起,止' → DateTime[]")
void coerceTimeRangeFormatted() {
Object r = coercer.coerceValue("2026-06-15 00:00:00,2026-06-18 23:59:59", "TIME", "UPDATETIME");
org.junit.jupiter.api.Assertions.assertInstanceOf(org.joda.time.DateTime[].class, r);
org.joda.time.DateTime[] arr = (org.joda.time.DateTime[]) r;
org.junit.jupiter.api.Assertions.assertTrue(arr[0].isBefore(arr[1]));
}
@Test
@DisplayName("coerceValue: TIME 区间一侧空 '起,' → DateTime[]{起, null}(引擎只加下界)")
void coerceTimeRangeOpenEnd() {
Object r = coercer.coerceValue("1749978060,", "TIME", "UPDATETIME");
org.junit.jupiter.api.Assertions.assertInstanceOf(org.joda.time.DateTime[].class, r);
org.joda.time.DateTime[] arr = (org.joda.time.DateTime[]) r;
assertEquals(1749978060_000L, arr[0].getMillis());
assertNull(arr[1], "止侧空 → null(不加上界约束)");
}
@Test
@DisplayName("coerceValue: TIME 区间无法解析 → 原 String 保留(fail-safe)")
void coerceTimeRangeUnparseable() {
Object r = coercer.coerceValue("foo,bar", "TIME", "UPDATETIME");
assertEquals("foo,bar", r);
}
// ── coerce(contentXml, map) ───────────────────────────────────────────────
@Test

View File

@@ -83,6 +83,18 @@ class FlowNameResolverTest {
assertEquals("VIEW_JGGL_SEARCH", r.definition().getKey());
}
@Test
@DisplayName("_SEARCH 有真实 serviceflow → real-first 优先真实流(NAMED_READ),不合成")
void searchSuffixWithRealFlow_prefersNamedRead() {
// real-first(忠实旧引擎):有真实定制流(自定义排序/join,如登录历史 order by LOGINTIME)就用真实流,
// 不走合成默认流(避免合成的 order by CREATETIME 盖住真实排序 / 无 createtime 列报错)。
when(jdbc.queryForObject(contains("sys_serviceflow"), eq(Integer.class),
eq("SYS_USERLOGIN_HISTORY_SEARCH")))
.thenReturn(1);
ResolvedFlow r = resolver.resolve("SYS_USERLOGIN_HISTORY_SEARCH");
assertEquals(ResolveType.NAMED_READ, r.type(), "有真实流应优先真实流,不合成");
}
@Test
@DisplayName("_SEARCH 后缀但实体不存在 → 走第3级(命名查询),不命中 → ORPHAN")
void searchSuffixEntityNotFound_fallsToOrphan() {

View File

@@ -0,0 +1,114 @@
package com.eip4.platform.metadata.web;
import static org.junit.jupiter.api.Assertions.assertEquals;
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.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.joda.time.DateTime;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import com.dsasp.server.common.log.service.SystemLogManager;
/** {@link LogController} 单测(mock systemLogManager,不连库)。 */
class LogControllerTest {
@Test
void deleteAll_调用引擎deleteAll() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
Map<String, Object> r = c.deleteAll();
verify(svc).deleteAll();
assertEquals(0, r.get("status"));
}
@Test
void deleteByType_body透传类型() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
Map<String, Object> body = new HashMap<>();
body.put("type", "Errors");
Map<String, Object> r = c.deleteByType(null, body);
verify(svc).deleteByType("Errors");
assertEquals(0, r.get("status"));
}
@Test
void deleteByType_查询参亦可() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
c.deleteByType("Warnings", null);
verify(svc).deleteByType("Warnings");
}
@Test
void deleteByType_空类型不删除() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
c.deleteByType(null, new HashMap<>());
verify(svc, never()).deleteByType(anyString());
}
@Test
void deleteByType_非枚举值拒绝防注入() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
Map<String, Object> body = new HashMap<>();
body.put("type", "x' OR '1'='1"); // 注入载荷
Map<String, Object> r = c.deleteByType(null, body);
verify(svc, never()).deleteByType(anyString()); // 白名单闸住,绝不下推
assertEquals(0, r.get("status"));
}
@Test
@SuppressWarnings("unchecked")
void deleteByLoginTime_解析USERID逗号串与LOGINTIME秒区间() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
Map<String, Object> body = new HashMap<>();
body.put("USERID", "u1, u2");
body.put("LOGINTIME", "1700000000,1700086400"); // amis datetime-range 秒
c.deleteByLoginTime(body);
ArgumentCaptor<List<String>> idCap = ArgumentCaptor.forClass(List.class);
ArgumentCaptor<DateTime[]> timeCap = ArgumentCaptor.forClass(DateTime[].class);
verify(svc).deleteByLoginTime(idCap.capture(), timeCap.capture());
assertEquals(List.of("u1", "u2"), idCap.getValue());
DateTime[] t = timeCap.getValue();
assertEquals(1700000000_000L, t[0].getMillis(), "秒应转毫秒");
assertEquals(1700086400_000L, t[1].getMillis());
}
@Test
void deleteByLoginTime_空条件传null删全部() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
c.deleteByLoginTime(new HashMap<>());
// 无 USERID/LOGINTIME → userIds=null, times=null(底层 DELETE ... WHERE 1=1 删全部,老引擎同语义)
verify(svc).deleteByLoginTime(isNull(), isNull());
}
@Test
@SuppressWarnings("unchecked")
void deleteByLoginTime_仅时间无用户() {
SystemLogManager svc = mock(SystemLogManager.class);
LogController c = new LogController(svc);
Map<String, Object> body = new HashMap<>();
body.put("LOGINTIME", "1700000000,1700086400");
c.deleteByLoginTime(body);
ArgumentCaptor<DateTime[]> timeCap = ArgumentCaptor.forClass(DateTime[].class);
verify(svc).deleteByLoginTime(isNull(), timeCap.capture());
assertEquals(1700000000_000L, timeCap.getValue()[0].getMillis());
}
}

View File

@@ -33,6 +33,7 @@ import com.dsasp.server.common.dataDic.service.DataDicService;
import com.dsasp.server.common.dataDic.service.POJOCRUDService;
import com.dsasp.server.common.user.service.LoggedInUser;
import com.dsasp.server.common.exception.PrivilegeException;
import com.eip4.platform.metadata.flow.UserColumnResolver;
import com.eip4.platform.metadata.security.IdentifierWhitelist;
import com.eip4.platform.metadata.security.IllegalIdentifierException;
@@ -137,7 +138,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"), fakeRow("g2", "普通组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);
assertEquals(0, resp.get("status"));
@@ -162,7 +163,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// path 用实体表名(小写也可,内部 toUpperCase)
Map<String, Object> resp = c.list("sys_usergroup", null, 1, 20, null, null, null, null, null, null, null, null);
@@ -179,7 +180,7 @@ class PickerControllerTest {
when(dic.getReferenceEntityTableName(REF_ID)).thenReturn(TABLE);
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
c.list(REF_ID, "管理'员%组", 1, 20, null, null, null, null, null, null, null, null);
@@ -200,7 +201,7 @@ class PickerControllerTest {
when(dic.getReferenceEntityTableName(REF_ID)).thenReturn(TABLE);
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
c.list(REF_ID, null, 3, 15, null, null, null, null, null, null, null, null);
@@ -211,6 +212,75 @@ class PickerControllerTest {
assertEquals(15, condCap.getValue().get(POJOCRUDService.PAGE_SIZE));
}
/** fakeInfo 之上再加一列 PARENTORGID(filterscript 级联过滤列),供列过滤测试白名单命中。 */
private POJOInfo fakeInfoWithParentOrg() {
POJOInfo info = mock(POJOInfo.class);
when(info.hasKeyColumn()).thenReturn(true);
when(info.getKeyColumnName()).thenReturn(KEY);
when(info.getColumnCount()).thenReturn(3);
when(info.getColumnName(0)).thenReturn(KEY);
when(info.getColumnName(1)).thenReturn(LABEL);
when(info.getColumnName(2)).thenReturn("PARENTORGID");
when(info.isIdentifier(0)).thenReturn(false);
when(info.isIdentifier(1)).thenReturn(true);
when(info.isIdentifier(2)).thenReturn(false);
when(info.getDisplayIndex()).thenReturn(1);
org.mockito.Mockito.doReturn(String.class).when(info).getColumnClass(org.mockito.ArgumentMatchers.anyInt());
return info;
}
@Test
@DisplayName("3b. 级联列过滤:allParams 里命中表真实列的参 → 转义后进引擎等值条件(filterscript 级联)")
void listAppliesColumnFilterFromAllParams() {
POJOCRUDService engine = mock(POJOCRUDService.class);
DataDicService dic = mock(DataDicService.class);
IdentifierWhitelist wl = mock(IdentifierWhitelist.class);
when(dic.getReferenceEntityTableName(REF_ID)).thenReturn(TABLE);
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache(TABLE, fakeInfoWithParentOrg());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
org.springframework.util.MultiValueMap<String, String> all =
new org.springframework.util.LinkedMultiValueMap<>();
all.add("PARENTORGID", "org-123");
all.add("page", "1"); // 控制参,不得当过滤列
all.add("perPage", "20"); // 控制参,不得当过滤列
c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, all);
@SuppressWarnings("unchecked")
ArgumentCaptor<Map<String, Object>> condCap = ArgumentCaptor.forClass(Map.class);
verify(engine).listSelect(condCap.capture(), eq(TABLE), any(Properties.class));
Map<String, Object> cond = condCap.getValue();
assertEquals("org-123", cond.get("PARENTORGID")); // 真实列 → 等值过滤条件(值无特殊字符,转义后不变)
assertFalse(cond.containsKey("page")); // 控制参不进条件
assertFalse(cond.containsKey("perPage"));
}
@Test
@DisplayName("3c. 级联列过滤:非表列参与空值参一律忽略,不污染引擎条件")
void listIgnoresUnknownAndBlankColumnParams() {
POJOCRUDService engine = mock(POJOCRUDService.class);
DataDicService dic = mock(DataDicService.class);
IdentifierWhitelist wl = mock(IdentifierWhitelist.class);
when(dic.getReferenceEntityTableName(REF_ID)).thenReturn(TABLE);
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache(TABLE, fakeInfoWithParentOrg());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
org.springframework.util.MultiValueMap<String, String> all =
new org.springframework.util.LinkedMultiValueMap<>();
all.add("NOTACOLUMN", "x"); // 非表列 → 忽略
all.add("PARENTORGID", ""); // 空值(如 amis 触发器未选)→ 忽略(不过滤,列出全部)
c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, all);
@SuppressWarnings("unchecked")
ArgumentCaptor<Map<String, Object>> condCap = ArgumentCaptor.forClass(Map.class);
verify(engine).listSelect(condCap.capture(), eq(TABLE), any(Properties.class));
Map<String, Object> cond = condCap.getValue();
assertFalse(cond.containsKey("NOTACOLUMN"));
assertFalse(cond.containsKey("PARENTORGID")); // 空值不下推
}
@Test
@DisplayName("5. 白名单负例:解析出的表名非法 → 抛 IllegalIdentifierException(异常处理器转 400)")
void illegalTableRejected() {
@@ -220,7 +290,7 @@ class PickerControllerTest {
when(dic.getReferenceEntityTableName("NOPE")).thenReturn(null);
doThrow(new IllegalIdentifierException("非法实体或元数据不存在: NOPE"))
.when(wl).requireLegalTable(eq("NOPE"));
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
IllegalIdentifierException ex = assertThrows(IllegalIdentifierException.class,
() -> c.list("nope", null, 1, 20, null, null, null, null, null, null, null, null));
@@ -236,7 +306,7 @@ class PickerControllerTest {
when(dic.getReferenceEntityTableName(REF_ID)).thenReturn(TABLE);
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
c.list(REF_ID, null, 1, 20, null, null, null, "alice", "role-a,role-b", null, null, null);
@@ -259,7 +329,7 @@ class PickerControllerTest {
POJOInfo noKey = mock(POJOInfo.class);
when(noKey.hasKeyColumn()).thenReturn(false);
seedPoInfoCache(TABLE, noKey);
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
assertThrows(IllegalIdentifierException.class,
() -> c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null));
@@ -294,7 +364,7 @@ class PickerControllerTest {
when(dic.getSYSEntity(entityId)).thenReturn(sysEntity);
when(engine.listSelect(any(), eq("PM_PROJECT"), any(Properties.class))).thenReturn(engineResult());
seedPoInfoCache("PM_PROJECT", fakeInfo());
PickerController c = new PickerController(engine, dic, wl, jdbc);
PickerController c = new PickerController(engine, dic, wl, jdbc, new UserColumnResolver(jdbc));
Map<String, Object> resp = c.list(dialogId, null, 1, 20, null, null, null, null, null, null, null, null);
assertEquals(0, resp.get("status"));
@@ -326,7 +396,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("u1", "罗来伟"));
when(engine.listSelect(any(), eq("VIEW_SYS_USER"), any(Properties.class))).thenReturn(result);
seedPoInfoCache("VIEW_SYS_USER", fakeInfo());
PickerController c = new PickerController(engine, dic, wl, jdbc);
PickerController c = new PickerController(engine, dic, wl, jdbc, new UserColumnResolver(jdbc));
Map<String, Object> resp = c.list(dialogId, null, 1, 20, null, null, null, null, null, null, null, null);
@@ -378,7 +448,7 @@ class PickerControllerTest {
result.put(POJOCRUDService.LIST_RESULT, List.of(row));
result.put(POJOCRUDService.PAGE_COUNT, 1L);
when(engine.listSelect(any(), eq("VIEW_SYS_USER"), any(Properties.class))).thenReturn(result);
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);
@@ -410,7 +480,7 @@ class PickerControllerTest {
// 引擎只接受 ADMIN 上下文调用(此处不限 ctx,但后面断言 ctx.CURRENTUSER==ADMIN)
when(engine.listSelect(any(), eq("VIEW_SYS_USER"), any(Properties.class))).thenReturn(result);
seedPoInfoCache("VIEW_SYS_USER", fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// 以非 admin 用户身份调用(asUser=ceshi,模拟真实登录用户)
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);
@@ -449,7 +519,7 @@ class PickerControllerTest {
when(engine.listSelect(any(), eq("PM_PROJECT"), any(Properties.class)))
.thenThrow(new PrivilegeException("没有PM_PROJECT数据访问权限"));
seedPoInfoCache("PM_PROJECT", fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// 不应抛异常,不应 500
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);
@@ -489,7 +559,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.resolve(REF_ID, "g1", null, null, null, null);
@@ -525,7 +595,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> listResp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);
@SuppressWarnings("unchecked")
@@ -554,7 +624,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g2", "普通组"), fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.resolve(REF_ID, "g1,g2", null, null, null, null);
@@ -580,7 +650,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.resolve(REF_ID, "g1,gX", null, null, null, null);
@@ -601,7 +671,7 @@ class PickerControllerTest {
POJOCRUDService engine = mock(POJOCRUDService.class);
DataDicService dic = mock(DataDicService.class);
IdentifierWhitelist wl = mock(IdentifierWhitelist.class);
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.resolve(REF_ID, " ", null, null, null, null);
@@ -624,7 +694,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1 ", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// 入参也带补白("g1 ")
Map<String, Object> resp = c.resolve(REF_ID, "g1 ", null, null, null, null);
@@ -649,7 +719,7 @@ class PickerControllerTest {
when(engine.listSelect(any(), eq("PM_PROJECT"), any(Properties.class)))
.thenThrow(new PrivilegeException("没有PM_PROJECT数据访问权限"));
seedPoInfoCache("PM_PROJECT", fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.resolve(REF_ID, "p1", null, null, null, null);
@@ -681,7 +751,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// amis 同时带 value 与 _id;op=loadOptions → 短路解析
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, "loadOptions", "g1", "g1",
@@ -716,7 +786,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// value=null,_id=g1
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, "loadOptions", null, "g1",
@@ -743,7 +813,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"), fakeRow("g2", "普通组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
// amis 多选序列化:value[0]=g1&value[1]=g2&op=loadOptions(scalar value/_id 均空)
org.springframework.util.MultiValueMap<String, String> all =
@@ -778,7 +848,7 @@ class PickerControllerTest {
Map<String, Object> result = engineResult(fakeRow("g1", "管理员组"), fakeRow("g2", "普通组"));
when(engine.listSelect(any(), eq(TABLE), any(Properties.class))).thenReturn(result);
seedPoInfoCache(TABLE, fakeInfo());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc());
PickerController c = new PickerController(engine, dic, wl, emptyTemplateJdbc(), new UserColumnResolver(emptyTemplateJdbc()));
Map<String, Object> resp = c.list(REF_ID, null, 1, 20, null, null, null, null, null, null, null, null);