diff --git a/.workbuddy/memory/2026-10-31.md b/.workbuddy/memory/2026-10-31.md index 98dc491..98267c6 100644 --- a/.workbuddy/memory/2026-10-31.md +++ b/.workbuddy/memory/2026-10-31.md @@ -114,3 +114,83 @@ PortalManage / message / file / extend / 甘特图)⇒ 真做也只是恒空 s 2. `permission/Standing`(6) / `PermissionGroup`(6) / `Action`(3) 3. `system/System`(11) + `system/SysConfig`(6) 4. `message` / `file` / `extend` / 低代码 ⇒ 批量恒空 stub(只消红条,不建表) + +--- + +# 第三波批次 1(05:00–07:00):`permission/Users/Current/*` 23 条 + +## 结论 + +- 面 B 端点 102 → **125** 条;契约 132 → **155** 条;`tables` 16 → **18** + (新增官方 `base_user_extra` / `base_sign_img`)。 +- 官方台账覆盖 121/128 → **144/151**。 +- `cargo test` 221 → **226**(新增 5 条)。六闸全绿。 +- commit `5601a66`。 + +## 坑 + +- 🔴 **`$N::integer` 不能用**:本仓参数**一律按 text 绑定**(`Option`)⇒ + 整型列必须写 `$N::text::integer`。 +- 🔴 **`$N::text[]` 同样不能用**:pglite-rs 会把它当 PG 数组类型 `_text` ⇒ 协议错。 + 用 `string_to_array($N::text, ',')`。 +- 🔴 **PG 拒「SQL 里有 $N 却没用它」**:`42P18` ⇒ 把该列写进 SET。 +- 🔴 **占位符与参数追加顺序必须逐字对齐**。 + +--- + +# 第三波批次 2(08:00–09:00):Standing / PermissionGroup / Action 21 条 + +## 结论 + +- 面 B 端点 125 → **146** 条;契约 155 → **176** 条;`tables` 18 → **21** + (新增官方 `base_standing` 15 列 / `base_permission_group` 16 列 / `base_action` 15 列)。 +- 官方台账覆盖 144/151 → **165/172**(implemented 160 / partial 5 / absent 7;oos 6 单列)。 +- `cargo test` 226 → **230**(新增 4 条,在 `tests/batch2_it.rs`)。 +- 六闸全绿:module 114 / boundary 11 / contract 10 / citations 4 / perm-smoke 43 / + perm-smoke-jnpf **23/23(面 B 首次全覆盖,0 SKIP)**。 +- 运行时端到端验证 **29/29**(Python 验证器 `/tmp/ssw_batch2_verify.py`)。 + +## 官方 DDL 陷阱(逐字照抄,别自己"优化") + +- `base_action.f_enabled_mark` 是 **VARCHAR(11)**(不是 INTEGER)⇒ 投影用 + `COALESCE(f_enabled_mark,'0')`,**不加 integer CAST**。 +- `base_standing.f_is_system`:**1=系统身份 / 2=自定义** ⇒ 新建默认写 **2**, + 投影归一化成 `isSystem` 0/1(`CASE WHEN COALESCE(f_is_system,0)=1 THEN 1 ELSE 0 END`)。 +- `base_action.f_type`:**1=自定义** ⇒ 新建强制写 1。 +- 官方 DDL 行号(`JNPF-PostgreSQL.sql`):`base_action`:1 / `base_permission_group`:3278 / + `base_standing`:4071。 +- 🔴 官方 `PermissionGroupController.list` 会用 `userService.getFullNameByIds` 把 + `f_permission_member` 的 **id 串换成用户名串** ⇒ 抄控制器不能只抄模型。 + +## 本轮修的 4 个真 bug(都有回归测试 + 反自证) + +| # | 症状 | 根因 | 修法 | +|---|---|---|---| +| ① | `GET /PermissionGroup/PermissionMember/{id}` → 500 / `data:null` | `f_id = ANY($1::text[])` ⇒ pglite-rs 当成数组类型 `_text` | `ANY(string_to_array($1::text, ','))` | +| ② | `DELETE /PermissionGroup/{id}` → 500 `42P18` | 软删 SQL 带了 `$1` 但没用到 | `f_delete_user_id = $1::text` 写进 SET | +| ③ | `DELETE /Standing/{id}` 后**关联残留**(静默 bug) | 软删关联的**占位符与参数顺序错位** | `rel=[item_type,id,account]` + SQL 对齐 | +| ④ | 权限组列表 `permissionMember` 返 **uuid 串** | 漏了官方 `getFullNameByIds` | 子查询 `string_agg` 换成人名串 | + +**反自证全部做过**:逐个回退修复 ⇒ 测试精确复现原始报错 +(`cannot convert between String and _text` / `42P18` / 关联残留 n=1 / uuid 串)⇒ 恢复后 4 条全过。 + +## 坑(第三波批次 2 新增) + +- 🔴 **Bash 多层嵌套引号的验证脚本必然引号不闭合**:`bash -n` 报 `unexpected EOF` 但 + **定位不到行**(我自己写了个递归引号状态机也定位错了)。⇒ **直接用 Python 写验证器** + (`urllib.request` + `build_opener(ProxyHandler({}))` 绕过本机代理), + 不要再跟 bash 引号较劲(脚本在 `/tmp/ssw_batch2_verify.py`)。 +- 🔴 **尺子跑的是 `target/release/ssw-platform`,不是 debug 产物** ⇒ 改完代码跑尺子前 + **必须 `cargo build --release`**,否则尺子跑旧二进制 ⇒ 表现为「刚修好的端点还是 405」 + (这次 `perm-smoke-jnpf` 断言 20 就是这么红的:`POST /api/permission/Users` → 405)。 + 重建 release 后 **23/23 全绿、0 SKIP**(批次 1 那 4 条 SKIP 其实早就落地了)。 +- 🔴 官方 DDL 大文件含 NUL 字节 ⇒ `grep` 要加 `-a` 才能搜到(`grep -an`)。 +- 🔴 `find`/`grep` 扫大目录会被 SIGTERM(exit 137)⇒ 限定路径 + `awk`/`sed`。 +- 🔴 反自证注入 bug 时**小心别顺手引入语法错误**:少一个逗号会变成 `42601 syntax error`, + 那样测到的不是原 bug ⇒ 断言要能分辨(看错误码是不是预期的那个)。 + +## 下一步(第三波批次 3) + +1. `system/System`(11) + `system/SysConfig`(6) 系统配置页 +2. `message` / `file` / `extend` / 低代码 ⇒ 批量恒空 stub(只消红条,不建表) + diff --git a/HANDOFF.md b/HANDOFF.md index 5c01de3..230f981 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -1,6 +1,6 @@ # HANDOFF —— 交给下一个 session 的现场交接 -> 更新于 2026-10-31 05:00。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), +> 更新于 2026-10-31 09:00。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), > 最后看 `.workbuddy/memory/` 最近一天的日志(踩过的坑)。 > 无人值守时不要问用户,选最保守可行的方案继续,并把决策写回本文件。 @@ -39,7 +39,7 @@ --- -## 1. 一句话现状(2026-10-31 05:00 夜班更新) +## 1. 一句话现状(2026-10-31 09:00 批次 2 收工) **✅ 前端已经在浏览器里真跑起来了,用户管理页可渲染、列表/新增/编辑/删除全部可用。** @@ -48,17 +48,49 @@ - 机构管理 `/permission/organize` 也正常渲染(空状态,零报错)。 **第二波(04:00–05:00)又干了一批,现在数字是这样:** -- 契约端点 **132 条**(面 B **102** 条);`tables` 12 → **16**(新增 `base_group`、 - `base_position`、`base_dictionary_type`、`base_dictionary_data`)。 +- 契约端点 **176 条**(面 B **146** 条);`tables` 12 → **21**(新增 `base_group`、 + `base_position`、`base_dictionary_type`、`base_dictionary_data`、`base_user_extra`、 + `base_sign_img`、`base_standing`、`base_permission_group`、`base_action`)。 - 六闸全绿:`check-module 114` / `check-boundary 11` / `check-contract 10` / - `check-citations 4` / `perm-smoke 43` / `perm-smoke-jnpf 23`,`cargo test` **221 全过**。 -- 官方端点台账覆盖 **121/128**(从起点 49/72 涨上来)。 + `check-citations 4` / `perm-smoke 43` / `perm-smoke-jnpf 23`,`cargo test` **230 全过**。 +- 官方端点台账覆盖 **165/172**(implemented 160 / partial 5 / absent 7)。 - 浏览器实测 5 个页面**零非 200**:用户管理、机构管理、角色管理、菜单管理、岗位。 菜单管理页能正常显示树(系统管理 → 用户/角色/机构/菜单管理)。 -上一版说「页面从未渲染过一次」——**这个未知已经消除**。 +### 批次 2(2026-10-31 08:00–09:00)做了什么 + +`permission/Standing`(8) + `permission/PermissionGroup`(8) + `permission/Action`(5) = **21 条面 B 端点**, +新增官方表 `base_standing`(15 列) / `base_permission_group`(16 列) / `base_action`(15 列)。 + +**官方 DDL 逐字对齐**(行号已核对 `JNPF-PostgreSQL.sql`): +`base_action`:1 / `base_permission_group`:3278 / `base_standing`:4071。 + +🔴 **官方陷阱已照抄**:`base_action.f_enabled_mark` 是 **VARCHAR(11)**(不是 INTEGER)⇒ +投影用 `COALESCE(f_enabled_mark,'0')`,**不加 integer CAST**。 + +🔴 **官方语义已对齐**: +- `base_standing.f_is_system`:**1=系统身份 / 2=自定义** ⇒ 新建默认写 **2**,投影归一化成 `isSystem` 0/1。 +- `base_action.f_type`:**1=自定义** ⇒ 新建强制写 1(前端 `record.type == 1 ? '自定义' : '系统'`)。 +- `PermissionGroupController.list` 会用 `userService.getFullNameByIds` 把 `f_permission_member` + 的 **id 串换成用户名串** ⇒ 本仓用子查询 `string_agg(...)` 做同样的替换。 + +### 🔴 本轮踩到并解决的 4 个真 bug(都有回归测试 + 反自证) + +| # | 症状 | 根因 | 修法 | +|---|---|---|---| +| ① | `GET /PermissionGroup/PermissionMember/{id}` → 500 / `data:null` | `f_id = ANY($1::text[])` ⇒ pglite-rs 把 `$1::text[]` 当成 PG 数组类型 `_text` | 改 `ANY(string_to_array($1::text, ','))`(**函数在 SQL 里做** ⇒ 参数仍是 text) | +| ② | `DELETE /PermissionGroup/{id}` → 500 `42P18` | 软删 `base_authorize` 的 SQL 带了 `$1` 但 WHERE/赋值里**没用到** ⇒ PG 拒「无法确定 $1 类型」 | 把 `f_delete_user_id = $1::text` 写进 SET(既是审计列,也用掉参数) | +| ③ | `DELETE /Standing/{id}` 后**关联残留**(静默) | 软删关联的**占位符与参数顺序错位**(SQL `$1`=item_type、`$2`=item_id,参数传 `[account, id]`) | `rel = [item_type, id, account]` + SQL 改 `$1/$2/$3` 对齐 | +| ④ | 权限组列表 `permissionMember` 返**uuid 串** | 漏了官方的 `getFullNameByIds` 替换 | 子查询 `string_agg` 换成人名串 | + +回归测试:`src/backend/tests/batch2_it.rs`(**4 条**,每个钉一个 bug)。 +**反自证全部做过**:逐个把修复回退 ⇒ 测试精确复现原始报错(`cannot convert between String and _text` / +`42P18` / 关联残留 n=1 / uuid 串)⇒ 恢复后 4 条全过。 + +### 🔴 上一版说「页面从未渲染过一次」——**这个未知已经消除**。 + +### 🔴 上一批(第一批)踩到并解决的 4 个真 bug -🔴 **本轮踩到并解决的 4 个真 bug**(都是「页面能打开但功能不对」这一类): 1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端 `handleUpdatePreferences` 抛异常 ⇒ 登录后立刻跳 Logout(表现为「登录无效原地打转」)。 2. 菜单 `urlAddress` 走的是**面 B 路径** `permission/user`,不是面 A 的 `system/User` ⇒ @@ -76,8 +108,10 @@ ```bash cd ~/Desktop/workspace/ssw-platform RUSTC_WRAPPER=sccache cargo build --manifest-path src/backend/Cargo.toml # 改代码后 +# 🔴 **尺子跑的是 release 产物** ⇒ 跑尺子前必须 `cargo build --release` +RUSTC_WRAPPER=sccache cargo build --release --manifest-path src/backend/Cargo.toml nohup env PORT=30000 ./target/debug/ssw-platform > /tmp/ssw-backend.log 2>&1 & # 后台起 -curl -s http://127.0.0.1:30000/api/health # 期望 {"ok":true,"tables":13,...}(新增 base_group) +curl -s http://127.0.0.1:30000/api/health # 期望 {"ok":true,"tables":21,...} ``` 拿 token(面 B): @@ -197,9 +231,11 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c ' ### P4 —— 剩下的(按 §0-bis 的全景表,从上往下做) -1. `permission/Users/Current/*` 个人设置 14 条(BaseInfo/改密码/主题/语言/头像/签名/saas) -2. `permission/Standing`(6) / `PermissionGroup`(6) / `Action`(3) -3. `system/System`(11) + `system/SysConfig`(6) 系统配置页 +1. ~~`permission/Users/Current/*` 个人设置 14 条(BaseInfo/改密码/主题/语言/头像/签名/saas)~~ + ✅ **批次 1 做完(实际 23 条)**——新表 `base_user_extra` / `base_sign_img` +2. ~~`permission/Standing`(6) / `PermissionGroup`(6) / `Action`(3)~~ + ✅ **批次 2 做完(实际 21 条)**——新表 `base_standing` / `base_permission_group` / `base_action` +3. `system/System`(11) + `system/SysConfig`(6) 系统配置页 ← **下一个** 4. `message`(53) / `file`(32) / `extend`(53) / 低代码模块 ⇒ **批量恒空 stub** **实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套 @@ -220,6 +256,8 @@ PORT=30000 ./target/debug/ssw-platform & python3 scripts/probe-page.py docs/fe/page-user.tsv # 4) 单测 + 六闸 RUSTC_WRAPPER=sccache cargo test --manifest-path src/backend/Cargo.toml +# 🔴 **尺子跑的是 release 产物** ⇒ 跑尺子前必须先 build --release +RUSTC_WRAPPER=sccache cargo build --release --manifest-path src/backend/Cargo.toml for s in check-module check-boundary check-contract check-citations; do bash scripts/$s.sh; done bash scripts/perm-smoke.sh ENC_BIN="$PWD/target/debug/ssw-platform" bash scripts/perm-smoke-jnpf.sh @@ -257,6 +295,24 @@ ENC_BIN="$PWD/target/debug/ssw-platform" bash scripts/perm-smoke-jnpf.sh - 🔴 `.gitignore` 已挡 `target/`(1.7G) 与 `src/backend/data/`(38M);`git add -A` 前先 `git diff --cached --name-only | wc -l` 确认没暴涨。 +### 批次 2 新增的坑 + +- 🔴 **PG 数组参数一律不能写 `$N::text[]`**:pglite-rs 0.2.7 会把它当成 PG 数组类型 `_text`, + 而本仓参数**一律按 text 绑定**(`Option`)⇒ 协议错 + `cannot convert between the Rust type String and the Postgres type _text`。 + ⇒ 改成 `= ANY(string_to_array($N::text, ','))`(**函数在 SQL 里做**)。 +- 🔴 **PG 会拒「SQL 里有 $N 但没用它」**:`42P18: could not determine data type of parameter $1`。 + ⇒ 凡是留了 `$N` 的软删 SQL,都要把对应列写进 SET(`f_delete_user_id = $N::text`)。 +- 🔴 **占位符顺序必须与参数追加顺序逐字对齐**(不是「大致对上」)⇒ 写完对着读一遍。 +- 🔴 **`base_action.f_enabled_mark` 是 VARCHAR(11)**(官方 DDL 陷阱)⇒ 别按整数 CAST。 +- 🔴 **`base_standing.f_is_system` 是 1=系统 / 2=自定义** ⇒ 新建写 **2**,不是 1。 +- 🔴 **官方 `list` 端点常有「id 串换人名串」的后处理**(`getFullNameByIds`)⇒ 抄控制器别只抄模型。 +- 🔴 **Bash 里写多层嵌套引号的 curl + python 验证脚本很容易引号不闭合**(`bash -n` 报 + `unexpected EOF` 但**定位不到行**)⇒ **直接用 Python 写验证器**(`urllib` + `ProxyHandler({})` + 绕过本机代理),别跟 bash 引号较劲。 +- 🔴 **尺子用的是 `target/release/ssw-platform`**,不是 debug 产物 ⇒ 改完代码跑尺子前 + **必须 `cargo build --release`**,否则尺子跑的是旧二进制(表现为「刚修好的端点还是 405」)。 + --- ## 6. 收工前(每一轮都要做) diff --git a/docs/contract.md b/docs/contract.md index 452ee2c..151f3d7 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1280,6 +1280,27 @@ B GET /api/permission/Users/Current/saasinfo 登录 platform B GET /api/permission/Users/Current/saasTenantName/{id} 登录 platform B POST /api/permission/Users/Current/saasjoin 登录 platform B DELETE /api/permission/Users/Current/{id}/saas 登录 platform +B GET /api/permission/Standing permission.identity platform +B POST /api/permission/Standing permission.identity platform +B GET /api/permission/Standing/list permission.identity platform +B GET /api/permission/Standing/{id} permission.identity platform +B PUT /api/permission/Standing/{id} permission.identity platform +B DELETE /api/permission/Standing/{id} permission.identity platform +B POST /api/permission/Standing/{id}/Actions/AddObject permission.identity platform +B POST /api/permission/Standing/{id}/Actions/DeleteObject permission.identity platform +B GET /api/permission/PermissionGroup permission.authGroup platform +B POST /api/permission/PermissionGroup permission.authGroup platform +B GET /api/permission/PermissionGroup/{id} permission.authGroup platform +B PUT /api/permission/PermissionGroup/{id} permission.authGroup platform +B DELETE /api/permission/PermissionGroup/{id} permission.authGroup platform +B POST /api/permission/PermissionGroup/{id}/Actions/Copy permission.authGroup platform +B GET /api/permission/PermissionGroup/PermissionMember/{id} permission.authGroup platform +B POST /api/permission/PermissionGroup/PermissionMember/{id} permission.authGroup platform +B GET /api/permission/Action permission.action platform +B POST /api/permission/Action permission.action platform +B GET /api/permission/Action/{id} permission.action platform +B PUT /api/permission/Action/{id} permission.action platform +B DELETE /api/permission/Action/{id} permission.action platform A GET /api/ssw/demo/DemoItem/List 登录 demo A POST /api/ssw/demo/DemoItem/Save 登录 demo A DELETE /api/ssw/demo/DemoItem/Delete 登录 demo @@ -1296,7 +1317,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 125 面 B 专属(官方 JNPF 形状) +B 146 面 B 专属(官方 JNPF 形状) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1469,6 +1490,27 @@ GET /api/permission/Users/Current/saasinfo implemented userSetting.ts:89 本仓 GET /api/permission/Users/Current/saasTenantName/{id} implemented userSetting.ts:93 本仓单租户 ⇒ 恒空串 POST /api/permission/Users/Current/saasjoin implemented userSetting.ts:77 本仓单租户 ⇒ **明确失败**(不做静默假成功) DELETE /api/permission/Users/Current/{id}/saas implemented userSetting.ts:81 本仓单租户 ⇒ **明确失败**(同上) +GET /api/permission/Standing implemented identity.ts:9 身份列表(PageListVO);新表 `base_standing`(官方 `JNPF-PostgreSQL.sql:4071`,15 列逐字);`isSystem` 归一化成 1/0 +POST /api/permission/Standing implemented identity.ts:13 `f_is_system` 默认写 **2**(自定义;官方 1=系统/2=自定义)+ 白名单写库 + 名称非空校验 +GET /api/permission/Standing/list implemented identity.ts:29 身份关联列表:`type=position` ⇒ 岗位,否则 ⇒ 角色;关系在 `base_authorize`(`f_item_type='standing'`) +GET /api/permission/Standing/{id} implemented identity.ts:21 身份详情(`StandingInfoVO`) +PUT /api/permission/Standing/{id} implemented identity.ts:17 **只 SET body 里出现的键** +DELETE /api/permission/Standing/{id} implemented identity.ts:25 软删 + 同步软删 `base_authorize` 的关联行 +POST /api/permission/Standing/{id}/Actions/AddObject implemented identity.ts:33 body `{ids, type}` ⇒ 写 `base_authorize`(`f_item_type='standing'`);幂等 +POST /api/permission/Standing/{id}/Actions/DeleteObject implemented identity.ts:37 body `{ids, type}` ⇒ 关联行软删 +GET /api/permission/PermissionGroup implemented authGroup.ts:9 权限组列表(PageListVO);新表 `base_permission_group`(官方 `JNPF-PostgreSQL.sql:3278`,16 列逐字) +POST /api/permission/PermissionGroup implemented authGroup.ts:25 `f_type` 默认 1(自定义)+ 白名单写库 + 名称非空校验 +GET /api/permission/PermissionGroup/{id} implemented authGroup.ts:13 权限组详情 +PUT /api/permission/PermissionGroup/{id} implemented authGroup.ts:21 **只 SET body 里出现的键** +DELETE /api/permission/PermissionGroup/{id} implemented authGroup.ts:17 软删 + 同步软删该组的 `base_authorize` 行 +POST /api/permission/PermissionGroup/{id}/Actions/Copy implemented authGroup.ts:29 `fullName` 加 `.副本<5 位>`、`enCode` 加同 5 位、**清空** `f_permission_member`、复制授权关系 +GET /api/permission/PermissionGroup/PermissionMember/{id} implemented authGroup.ts:33 成员列表(ListVO);`f_permission_member` 是**逗号分隔 id 串** +POST /api/permission/PermissionGroup/PermissionMember/{id} implemented authGroup.ts:37 body `{ids}` ⇒ 逗号串写回 `f_permission_member` +GET /api/permission/Action implemented action.ts:9 动作列表(PageListVO);新表 `base_action`(官方 `JNPF-PostgreSQL.sql:1`,15 列逐字);`type` 1=自定义/其它=系统 +POST /api/permission/Action implemented action.ts:13 `f_type` 强制 1(自定义,官方 `insertOrUpdate`);🔴 `f_enabled_mark` 是 **VARCHAR(11)**(官方陷阱) +GET /api/permission/Action/{id} implemented action.ts:21 动作详情 +PUT /api/permission/Action/{id} implemented action.ts:17 **只 SET body 里出现的键**;`f_enabled_mark` 不加 CAST(VARCHAR) +DELETE /api/permission/Action/{id} implemented action.ts:25 软删 [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 4a155a2..d2a4933 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -316,6 +316,74 @@ CREATE TABLE base_user_extra ( PRIMARY KEY (f_id, f_tenant_id) ); +-- 身份管理表 —— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 4071 行,`base_standing`) +-- 🔴 `f_is_system`:1=系统身份(不可编辑/删除),2=自定义。 +CREATE TABLE base_standing ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_en_code VARCHAR(200), + f_is_system INTEGER, + f_sort_code BIGINT, + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 权限组(权限集)—— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 3278 行,`base_permission_group`) +-- 🔴 `f_permission_member` 存**逗号分隔的用户 id 串**(官方 `StringJoiner(",")`)。 +CREATE TABLE base_permission_group ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_en_code VARCHAR(200), + f_permission_member VARCHAR(4000), + f_sort_code BIGINT, + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_type INTEGER, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 动作(按钮级权限)—— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql 第 1 行,`base_action`) +-- 🔴 **官方陷阱**:`f_enabled_mark` 在这张表里是 **VARCHAR(11)**(不是 INTEGER)—— +-- 与其它 `base_*` 表不同 ⇒ 本仓逐字照抄,别"顺手改成 INTEGER"。 +CREATE TABLE base_action ( + f_en_code VARCHAR(255), + f_description VARCHAR(255), + f_full_name VARCHAR(50), + f_id VARCHAR(50) NOT NULL, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_type INTEGER, + f_enabled_mark VARCHAR(11), + PRIMARY KEY (f_id, f_tenant_id) +); + CREATE TABLE base_user_relation ( f_id VARCHAR(50) NOT NULL, f_user_id VARCHAR(50), diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 837cfcd..3c4d992 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -42,7 +42,7 @@ use ssw_platform::routes; /// 多应用 MVP 新增了平台表 `base_system`(`SystemEntity` 注册表, /// 承载 `App-Code` → `systemId` 的映射),故清单现在是 **8 张** /// (原 7 张 + `base_system`)。 -const BASE_TABLES: [&str; 14] = [ +const BASE_TABLES: [&str; 17] = [ "base_group", "base_user", "base_role", @@ -57,6 +57,9 @@ const BASE_TABLES: [&str; 14] = [ "base_dictionary_data", "base_sign_img", "base_user_extra", + "base_standing", + "base_permission_group", + "base_action", ]; /// 命令行解析的结果(**纯数据**,便于单测)。 diff --git a/src/backend/src/platform/db.rs b/src/backend/src/platform/db.rs index fcdb5cf..ffd7a83 100644 --- a/src/backend/src/platform/db.rs +++ b/src/backend/src/platform/db.rs @@ -1055,23 +1055,24 @@ mod tests { } #[test] - fn schema_sql_has_eighteen_tables() { - // schema.sql 必须包含 18 张表的 CREATE TABLE - // (14 张 base_*:8 张官方 + base_system + base_group + base_position - // + 字典分类/字典数据 + base_sign_img + base_user_extra,+ 4 张业务表)。 + fn schema_sql_has_twentyone_tables() { + // schema.sql 必须包含 21 张表的 CREATE TABLE + // (17 张 base_*:8 张官方 + base_system + base_group + base_position + // + 字典分类/字典数据 + base_sign_img + base_user_extra + // + base_standing + base_permission_group + base_action,+ 4 张业务表)。 let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 18, "schema.sql 的 CREATE TABLE 数量应为 18"); + assert_eq!(count, 21, "schema.sql 的 CREATE TABLE 数量应为 21"); } /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。 #[test] fn ddl_tables_parses_every_create_table() { let tables = ddl_tables(); - assert_eq!(tables.len(), 18, "ddl_tables 应解析出 18 张表"); + assert_eq!(tables.len(), 21, "ddl_tables 应解析出 21 张表"); assert!(tables.iter().all(|t| !t.is_empty())); assert_eq!( tables.iter().collect::>().len(), - 18, + 21, "表名不许重复" ); // 8 张 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 diff --git a/src/backend/src/platform/jnpf.rs b/src/backend/src/platform/jnpf.rs index 510bd2e..b8ef8e3 100644 --- a/src/backend/src/platform/jnpf.rs +++ b/src/backend/src/platform/jnpf.rs @@ -69,6 +69,16 @@ const EN_ORGANIZE: &str = "permission.organize"; const EN_MENU: &str = "permission.menu"; /// `@SaCheckPermission("permission.position")`。 const EN_POSITION: &str = "permission.position"; +/// 🔴 `@SaCheckPermission("permission.identity")`(官方 `StandingController`)。 +const EN_IDENTITY: &str = "permission.identity"; +/// 🔴 `@SaCheckPermission("permission.authGroup")`(官方 `PermissionGroupController`)。 +const EN_AUTH_GROUP: &str = "permission.authGroup"; +/// 🔴 `@SaCheckPermission("permission.action")`。 +/// +/// 🔴 官方 `ActionController` 是 `{"permission.auth", "permission.role", "permission.action"}` +/// 的 **SaMode.OR** 三选一;本仓的 `guard()` 只吃**一个**点权限码 +/// ⇒ 取**动作自己的**那个(最贴近语义)。 +const EN_ACTION: &str = "permission.action"; /// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。 const MAX_TREE_DEPTH: usize = 32; @@ -5725,6 +5735,1316 @@ pub async fn self_saas_exit( fail(code::FAIL, "本系统为单租户部署,不存在可退出的企业") } +// ================================================================ 权限组(base_permission_group) + +/// 🔴 **列名只来自这张白名单**(官方 `JNPF-PostgreSQL.sql:3278` 的 16 列逐字)。 +/// +/// 🔴 `f_permission_member` 存的是**逗号分隔的用户 id 串**(官方 +/// `PermissionGroupController.permissionMember`:`entity.getPermissionMember().split(",")`)。 +const PERMISSION_GROUP_WRITE_FIELDS: [(&str, &str, &str); 5] = [ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("description", "f_description", ""), + ("enabledMark", "f_enabled_mark", "::integer"), + ("sortCode", "f_sort_code", "::bigint"), +]; + +/// 权限组投影(官方 `PermissionGroupListVO` 的字段)。 +/// +/// 🔴 官方 `PermissionGroupController.list` 会把 `f_permission_member` 里的 +/// **用户 id 串**换成**用户名串**(`userService.getFullNameByIds`)⇒ +/// 这里用子查询做同样的替换(**不是** id 串)。 +const PERMISSION_GROUP_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", f_description AS \"description\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", \ + COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + COALESCE(f_type, 0) AS \"type\", \ + COALESCE((SELECT string_agg(COALESCE(NULLIF(u.f_real_name, ''), u.f_account, ''), ',') \ + FROM base_user u \ + WHERE u.f_id = ANY(string_to_array(COALESCE(base_permission_group.f_permission_member, ''), ',')) \ + AND COALESCE(u.f_delete_mark,0) = 0), '') AS \"permissionMember\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\""; + +/// `GET /api/permission/PermissionGroup` —— 权限组列表(官方 `ActionResult.page`)。 +pub async fn permission_group_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AUTH_GROUP).await { + return resp; + } + let keyword = crate::platform::sys::query_param(&raw, "keyword"); + let keyword = keyword.trim().to_string(); + let page = Paging::of(&raw); + let (count_sql, list_sql, mut params): (String, String, Vec>) = if keyword.is_empty() { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_permission_group \ + WHERE COALESCE(f_delete_mark,0) = 0".to_string(), + format!( + "SELECT {PERMISSION_GROUP_PROJECTION} FROM base_permission_group \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $1::text::integer OFFSET $2::text::integer" + ), + vec![], + ) + } else { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_permission_group \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text)" + .to_string(), + format!( + "SELECT {PERMISSION_GROUP_PROJECTION} FROM base_permission_group \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text) \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $2::text::integer OFFSET $3::text::integer" + ), + vec![Some(format!("%{keyword}%"))], + ) + }; + let total = match state.db.query_json_params(&count_sql, ¶ms_of(¶ms)).await { + Ok(rows) => rows + .into_iter() + .next() + .and_then(|r| r["c"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "权限组总数查询"), + }; + params.push(Some(page.page_size.to_string())); + params.push(Some(page.offset.to_string())); + match state.db.query_json_params(&list_sql, ¶ms_of(¶ms)).await { + Ok(rows) => ok(page_list(page.current_page, page.page_size, total, rows)), + Err(e) => db_error(e, "权限组列表查询"), + } +} + +/// `GET /api/permission/PermissionGroup/{id}` —— 权限组详情。 +pub async fn permission_group_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AUTH_GROUP).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {PERMISSION_GROUP_PROJECTION} FROM base_permission_group \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1" + ); + match state.db.query_json_params(&sql, &[&id]).await { + Ok(rows) => match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, "权限组不存在"), + }, + Err(e) => db_error(e, "权限组详情查询"), + } +} + +/// `POST /api/permission/PermissionGroup` —— 新建权限组。 +pub async fn permission_group_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_AUTH_GROUP).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let full_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "名称不能为空"); + } + + let new_id = new_uuid(); + let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_full_name"]; + let mut casts: Vec<&str> = vec!["", "", ""]; + let mut values: Vec> = + vec![Some(new_id.clone()), Some("0".to_string()), Some(full_name)]; + + for (json_key, column, cast) in PERMISSION_GROUP_WRITE_FIELDS { + if column == "f_full_name" { + continue; + } + if obj.contains_key(json_key) { + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + } + if !obj.contains_key("enabledMark") { + columns.push("f_enabled_mark"); + casts.push("::integer"); + values.push(Some("1".to_string())); + } + if !obj.contains_key("sortCode") { + columns.push("f_sort_code"); + casts.push("::bigint"); + values.push(Some("0".to_string())); + } + // 🔴 `f_type`:官方注释「权限类型 1.自定义 0.全部」⇒ 默认 1(自定义)。 + if !obj.contains_key("type") { + columns.push("f_type"); + casts.push("::integer"); + values.push(Some("1".to_string())); + } else if let Some(t) = value_to_text(obj.get("type")) { + columns.push("f_type"); + casts.push("::integer"); + values.push(Some(t)); + } + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.account)); + columns.push("f_delete_mark"); + casts.push("::integer"); + values.push(Some("0".to_string())); + columns.push("f_creator_time"); + let mut marks: Vec = (0..values.len()) + .map(|i| placeholder(i + 1, casts[i])) + .collect(); + marks.push("now()".to_string()); + let sql = format!( + "INSERT INTO base_permission_group ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建权限组"); + } + ok(json!({ "id": new_id })) +} + +/// `PUT /api/permission/PermissionGroup/{id}` —— 改权限组(**只 SET body 里出现的键**)。 +pub async fn permission_group_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_AUTH_GROUP).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_permission_group \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "权限组查询"), + }; + if rows.is_empty() { + return fail(code::FAIL, "权限组不存在"); + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in PERMISSION_GROUP_WRITE_FIELDS { + if !obj.contains_key(json_key) { + continue; + } + values.push(value_to_text(obj.get(json_key))); + sets.push(format!("{} = ${}::text{}", column, values.len(), cast)); + } + if obj.contains_key("type") { + values.push(value_to_text(obj.get("type"))); + sets.push(format!("f_type = ${}::text::integer", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.account)); + sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_permission_group SET {} WHERE f_id = ${}::text", + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "修改权限组"); + } + ok(Value::Null) +} + +/// `DELETE /api/permission/PermissionGroup/{id}` —— 删权限组(软删 + 解绑授权)。 +pub async fn permission_group_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_AUTH_GROUP).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let values = [Some(user.account.clone()), Some(id.clone())]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_permission_group SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text WHERE f_id = $2::text \ + AND COALESCE(f_delete_mark,0) = 0", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "删除权限组"); + } + // 官方 `PermissionGroupController.delete` 还会删掉该组的授权关系。 + // 🔴 `$1` 必须**真的被用到**(PG 会拒「无法确定 $1 类型」)⇒ + // 这里把 `f_delete_user_id = $1` 一起写上(既是审计列,也用掉了参数)。 + let rel = [Some(user.account), Some(id)]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_authorize SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text \ + WHERE f_object_id = $2::text AND COALESCE(f_delete_mark,0) = 0", + ¶ms_of(&rel), + ) + .await + { + return db_error(e, "删除权限组授权关系"); + } + ok(Value::Null) +} + +/// `POST /api/permission/PermissionGroup/{id}/Actions/Copy` —— 复制权限组。 +/// +/// 🔴 官方 `PermissionGroupController.actionsCopy`: +/// - `fullName` 加 `.副本<5 位随机>`、`enCode` 加同样 5 位; +/// - **清空** `f_permission_member`; +/// - 授权关系逐条复制(`f_object_id` 换成新 id)。 +pub async fn permission_group_copy( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_AUTH_GROUP).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_description AS \"description\", COALESCE(f_sort_code,0) AS \"sortCode\", \ + COALESCE(f_enabled_mark,0) AS \"enabledMark\", COALESCE(f_type,0) AS \"type\" \ + FROM base_permission_group \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "权限组查询"), + }; + let Some(row) = rows.into_iter().next() else { + return fail(code::FAIL, "权限组不存在"); + }; + let full_name = row["fullName"].as_str().unwrap_or_default().to_string(); + let en_code = row["enCode"].as_str().unwrap_or_default().to_string(); + + // 🔴 5 位随机后缀(官方 `UUID.randomUUID().toString().substring(0, 5)`)。 + let suffix = &new_uuid()[..5]; + let new_full_name = format!("{full_name}.副本{suffix}"); + let new_en_code = format!("{en_code}{suffix}"); + if new_full_name.chars().count() > 50 || new_en_code.chars().count() > 50 { + return fail(code::FAIL, "名称或编码长度超过 50 个字符"); + } + + let new_id = new_uuid(); + let values = [ + Some(new_id.clone()), + Some(new_full_name), + Some(new_en_code), + value_to_text(row.get("description")), + value_to_text(row.get("sortCode")), + value_to_text(row.get("enabledMark")), + value_to_text(row.get("type")), + Some(user.account.clone()), + ]; + // 🔴 `f_permission_member` **清空**(官方 `entity.setPermissionMember(null)`)。 + let sql = "INSERT INTO base_permission_group \ + (f_id, f_full_name, f_en_code, f_description, f_sort_code, f_enabled_mark, \ + f_type, f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ + $6::text::integer, $7::text::integer, $8::text, now(), 0, '0')"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "复制权限组"); + } + + // 复制授权关系(`f_object_id` 换成新 id)。 + let auths = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_item_type AS \"itemType\", f_item_id AS \"itemId\", \ + f_object_type AS \"objectType\", f_sort_code AS \"sortCode\" \ + FROM base_authorize WHERE f_object_id = $1::text \ + AND COALESCE(f_delete_mark,0) = 0", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "权限组授权查询"), + }; + for auth in auths { + let row_id = new_uuid(); + let values = [ + Some(row_id), + value_to_text(auth.get("itemType")), + value_to_text(auth.get("itemId")), + Some(new_id.clone()), + value_to_text(auth.get("objectType")), + value_to_text(auth.get("sortCode")), + Some(user.account.clone()), + ]; + let sql = "INSERT INTO base_authorize \ + (f_id, f_item_type, f_item_id, f_object_id, f_object_type, f_sort_code, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, \ + $6::text::bigint, $7::text, now(), 0, '0')"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "复制权限组授权关系"); + } + } + ok(json!({ "id": new_id })) +} + +/// `GET /api/permission/PermissionGroup/PermissionMember/{id}` —— 权限组成员。 +/// +/// 🔴 官方返回 `ListVO`(`{list:[…]}`),成员是**用户**的简要信息 +/// (`UserIdListVo`:`id` / `fullName` / `headIcon` / `gender` / `mobilePhone` / `organize` / `type`)。 +pub async fn permission_group_member_list( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_AUTH_GROUP).await { + return resp; + } + let id = id.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT COALESCE(f_permission_member, '') AS \"member\" FROM base_permission_group \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "权限组成员查询"), + }; + let Some(row) = rows.into_iter().next() else { + return fail(code::FAIL, "权限组不存在"); + }; + let member = row["member"].as_str().unwrap_or_default().to_string(); + let ids = split_id_text(Some(member.as_str())); + if ids.is_empty() { + return ok(list_vo(Vec::new())); + } + // 🔴 `= ANY($1::text[])` **不行**:本仓参数一律按 text 绑定(`Option`), + // PG 会把 `$1::text[]` 当成 `_text`(数组类型)⇒ 协议错 + // ("cannot convert between the Rust type String and the Postgres type _text")。 + // ⇒ 改成 `string_to_array($1::text, ',')`(**函数在 SQL 里做** ⇒ 参数仍是 text)。 + let sql = "SELECT f_id AS \"id\", COALESCE(f_real_name, f_account, '') AS \"fullName\", \ + f_head_icon AS \"headIcon\", f_gender AS \"gender\", \ + f_mobile_phone AS \"mobilePhone\", '' AS \"organize\", 'user' AS \"type\" \ + FROM base_user \ + WHERE f_id = ANY(string_to_array($1::text, ',')) \ + AND COALESCE(f_delete_mark,0) = 0"; + let id_csv = ids.join(","); + match state.db.query_json_params(sql, &[&id_csv]).await { + Ok(rows) => ok(list_vo(rows)), + Err(e) => db_error(e, "权限组成员列表查询"), + } +} + +/// `POST /api/permission/PermissionGroup/PermissionMember/{id}` —— 保存权限组成员。 +/// +/// 🔴 官方 `savePermissionMember`:body `{ids:[…]}` ⇒ 逗号串写 `f_permission_member`。 +pub async fn permission_group_member_save( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_AUTH_GROUP).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_permission_group \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "权限组查询"), + }; + if rows.is_empty() { + return fail(code::FAIL, "权限组不存在"); + } + let ids = id_list(&obj); + let member = ids.join(","); + let values = [ + Some(member), + Some(user.account), + Some(id), + ]; + let sql = "UPDATE base_permission_group SET f_permission_member = $1::text, \ + f_last_modify_user_id = $2::text, f_last_modify_time = now() \ + WHERE f_id = $3::text"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "保存权限组成员"); + } + ok(Value::Null) +} + +// ================================================================ 动作管理(base_action) + +/// 🔴 **列名只来自这张白名单**(官方 `JNPF-PostgreSQL.sql:1` 的 15 列逐字)。 +/// +/// 🔴🔴 **官方陷阱**:`base_action.f_enabled_mark` 是 **VARCHAR(11)**(不是 INTEGER), +/// 官方注释「启用0,禁用1」⇒ 存的是**字符串** `'0'` / `'1'`。 +const ACTION_WRITE_FIELDS: [(&str, &str, &str); 4] = [ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("description", "f_description", ""), + ("sortCode", "f_sort_code", "::bigint"), +]; + +/// 动作投影(官方 `ActionEntity` 的字段)。 +/// +/// 🔴 `type`:**1=自定义 / 其它=系统**(前端 `action/index.vue`: +/// `record.type == 1 ? '自定义' : '系统'`)⇒ 原样透传,不做归一化。 +const ACTION_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", f_description AS \"description\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", \ + COALESCE(f_type, 0) AS \"type\", \ + COALESCE(f_enabled_mark, '0') AS \"enabledMark\""; + +/// `GET /api/permission/Action` —— 动作列表(官方 `ActionResult.page`)。 +pub async fn action_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_ACTION).await { + return resp; + } + let keyword = crate::platform::sys::query_param(&raw, "keyword"); + let keyword = keyword.trim().to_string(); + let page = Paging::of(&raw); + let (count_sql, list_sql, mut params): (String, String, Vec>) = if keyword.is_empty() { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_action \ + WHERE COALESCE(f_delete_mark,0) = 0".to_string(), + format!( + "SELECT {ACTION_PROJECTION} FROM base_action \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $1::text::integer OFFSET $2::text::integer" + ), + vec![], + ) + } else { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_action \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text \ + OR f_description ILIKE $1::text)".to_string(), + format!( + "SELECT {ACTION_PROJECTION} FROM base_action \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text \ + OR f_description ILIKE $1::text) \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $2::text::integer OFFSET $3::text::integer" + ), + vec![Some(format!("%{keyword}%"))], + ) + }; + let total = match state.db.query_json_params(&count_sql, ¶ms_of(¶ms)).await { + Ok(rows) => rows + .into_iter() + .next() + .and_then(|r| r["c"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "动作总数查询"), + }; + params.push(Some(page.page_size.to_string())); + params.push(Some(page.offset.to_string())); + match state.db.query_json_params(&list_sql, ¶ms_of(¶ms)).await { + Ok(rows) => ok(page_list(page.current_page, page.page_size, total, rows)), + Err(e) => db_error(e, "动作列表查询"), + } +} + +/// `GET /api/permission/Action/{id}` —— 动作详情。 +pub async fn action_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_ACTION).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {ACTION_PROJECTION} FROM base_action \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1" + ); + match state.db.query_json_params(&sql, &[&id]).await { + Ok(rows) => match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, "动作不存在"), + }, + Err(e) => db_error(e, "动作详情查询"), + } +} + +/// `POST /api/permission/Action` —— 新建动作。 +/// +/// 🔴 官方 `ActionServiceImpl.insertOrUpdate`:**新建一律 `type=1`(自定义)**。 +pub async fn action_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_ACTION).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let full_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "动作名称不能为空"); + } + let en_code = obj + .get("enCode") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if en_code.is_empty() { + return fail(code::FAIL, "动作编码不能为空"); + } + + let new_id = new_uuid(); + let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_full_name", "f_en_code"]; + let mut casts: Vec<&str> = vec!["", "", "", ""]; + let mut values: Vec> = vec![ + Some(new_id.clone()), + Some("0".to_string()), + Some(full_name), + Some(en_code), + ]; + + for (json_key, column, cast) in ACTION_WRITE_FIELDS { + if column == "f_full_name" || column == "f_en_code" { + continue; + } + if obj.contains_key(json_key) { + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + } + if !obj.contains_key("sortCode") { + columns.push("f_sort_code"); + casts.push("::bigint"); + values.push(Some("0".to_string())); + } + // 🔴 `f_type` = 1(自定义)—— 官方 `insertOrUpdate` 强制。 + columns.push("f_type"); + casts.push("::integer"); + values.push(Some("1".to_string())); + // 🔴 `f_enabled_mark` 是 **VARCHAR(11)** ⇒ 不加 CAST,直接传字符串。 + if !obj.contains_key("enabledMark") { + columns.push("f_enabled_mark"); + casts.push(""); + values.push(Some("0".to_string())); + } else if let Some(v) = value_to_text(obj.get("enabledMark")) { + columns.push("f_enabled_mark"); + casts.push(""); + values.push(Some(v)); + } + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.account)); + columns.push("f_delete_mark"); + casts.push("::integer"); + values.push(Some("0".to_string())); + columns.push("f_creator_time"); + let mut marks: Vec = (0..values.len()) + .map(|i| placeholder(i + 1, casts[i])) + .collect(); + marks.push("now()".to_string()); + let sql = format!( + "INSERT INTO base_action ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建动作"); + } + ok(json!({ "id": new_id })) +} + +/// `PUT /api/permission/Action/{id}` —— 改动作(**只 SET body 里出现的键**)。 +pub async fn action_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_ACTION).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_action \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "动作查询"), + }; + if rows.is_empty() { + return fail(code::FAIL, "动作不存在"); + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in ACTION_WRITE_FIELDS { + if !obj.contains_key(json_key) { + continue; + } + values.push(value_to_text(obj.get(json_key))); + sets.push(format!("{} = ${}::text{}", column, values.len(), cast)); + } + // 🔴 `f_enabled_mark` 是 VARCHAR(11) ⇒ 不加 CAST。 + if obj.contains_key("enabledMark") { + values.push(value_to_text(obj.get("enabledMark"))); + sets.push(format!("f_enabled_mark = ${}::text", values.len())); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.account)); + sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_action SET {} WHERE f_id = ${}::text", + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "修改动作"); + } + ok(Value::Null) +} + +/// `DELETE /api/permission/Action/{id}` —— 删动作(软删)。 +pub async fn action_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_ACTION).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let values = [Some(user.account), Some(id)]; + let sql = "UPDATE base_action SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text WHERE f_id = $2::text \ + AND COALESCE(f_delete_mark,0) = 0"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "删除动作"); + } + ok(Value::Null) +} + +// ================================================================ 身份管理(base_standing) + +/// 🔴 **列名只来自这张白名单**(官方 `JNPF-PostgreSQL.sql:4071` 的 15 列逐字)。 +/// +/// 🔴 官方 `f_is_system` 的语义是 **1=系统身份 / 2=自定义** +/// (`COMMENT ON COLUMN base_standing.f_is_system IS '是否系统(1-系统,2-自定义)'`) +/// ⇒ **新建默认写 2(自定义)**,不是 1。 +const STANDING_WRITE_FIELDS: [(&str, &str, &str); 5] = [ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("description", "f_description", ""), + ("enabledMark", "f_enabled_mark", "::integer"), + ("sortCode", "f_sort_code", "::bigint"), +]; + +/// 身份投影(`StandingVO` / `StandingInfoVO` 用到的字段)。 +/// +/// 🔴 `isSystem` **归一化成 1/0**(官方 `StandingController.list`: +/// `item.setIsSystem(Objects.equals(item.getIsSystem(), 1) ? 1 : 0)`) +/// ⇒ 前端 `!node.isSystem` 判断「系统身份不可编辑/不可删」才成立。 +const STANDING_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", f_description AS \"description\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", \ + CASE WHEN COALESCE(f_is_system, 0) = 1 THEN 1 ELSE 0 END AS \"isSystem\", \ + COALESCE(f_enabled_mark, 0) AS \"enabledMark\""; + +/// 🔴 官方 `PermissionConst` 的取值(`jnpf-common-core/.../constant/PermissionConst.java`): +/// `ROLE="role"` / `POSITION="position"` / `STAND="standing"`。 +const STANDING_ITEM_TYPE: &str = "standing"; +const STANDING_OBJECT_TYPE_ROLE: &str = "role"; +const STANDING_OBJECT_TYPE_POSITION: &str = "position"; + +/// `GET /api/permission/Standing` —— 身份列表(官方 `ActionResult.page` ⇒ `PageListVO`)。 +/// +/// 🔴 前端 `views/permission/identity/index.vue`: +/// `state.treeData = res.data.list || []` ⇒ **`data` 必须是有 `list` 的对象**。 +pub async fn standing_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_IDENTITY).await { + return resp; + } + let keyword = crate::platform::sys::query_param(&raw, "keyword"); + let keyword = keyword.trim().to_string(); + let page = Paging::of(&raw); + let (count_sql, list_sql, mut params): (String, String, Vec>) = if keyword.is_empty() { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_standing \ + WHERE COALESCE(f_delete_mark,0) = 0".to_string(), + format!( + "SELECT {STANDING_PROJECTION} FROM base_standing \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $1::text::integer OFFSET $2::text::integer" + ), + vec![], + ) + } else { + ( + "SELECT count(*)::bigint AS \"c\" FROM base_standing \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text)" + .to_string(), + format!( + "SELECT {STANDING_PROJECTION} FROM base_standing \ + WHERE COALESCE(f_delete_mark,0) = 0 \ + AND (f_full_name ILIKE $1::text OR f_en_code ILIKE $1::text) \ + ORDER BY f_sort_code ASC, f_full_name ASC \ + LIMIT $2::text::integer OFFSET $3::text::integer" + ), + vec![Some(format!("%{keyword}%"))], + ) + }; + let total = match state.db.query_json_params(&count_sql, ¶ms_of(¶ms)).await { + Ok(rows) => rows + .into_iter() + .next() + .and_then(|r| r["c"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "身份总数查询"), + }; + params.push(Some(page.page_size.to_string())); + params.push(Some(page.offset.to_string())); + match state.db.query_json_params(&list_sql, ¶ms_of(¶ms)).await { + Ok(rows) => ok(page_list(page.current_page, page.page_size, total, rows)), + Err(e) => db_error(e, "身份列表查询"), + } +} + +/// `GET /api/permission/Standing/{id}` —— 身份详情(官方 `StandingInfoVO`)。 +pub async fn standing_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_IDENTITY).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {STANDING_PROJECTION} FROM base_standing \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1" + ); + match state.db.query_json_params(&sql, &[&id]).await { + Ok(rows) => match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, "身份不存在"), + }, + Err(e) => db_error(e, "身份详情查询"), + } +} + +/// `POST /api/permission/Standing` —— 新建身份。 +/// +/// 🔴 官方 `StandingController.create` 返 `ActionResult.success(msg)`(**无 id**), +/// 但本仓面 B 的惯例是返 `{id}`(前端 `Form.vue` 不用返回值,返 `{id}` 更通用)。 +pub async fn standing_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_IDENTITY).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let full_name = obj + .get("fullName") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() { + return fail(code::FAIL, "名称不能为空"); + } + + let new_id = new_uuid(); + let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_full_name"]; + let mut casts: Vec<&str> = vec!["", "", ""]; + let mut values: Vec> = + vec![Some(new_id.clone()), Some("0".to_string()), Some(full_name)]; + + for (json_key, column, cast) in STANDING_WRITE_FIELDS { + if column == "f_full_name" { + continue; + } + if obj.contains_key(json_key) { + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + } + if !obj.contains_key("enabledMark") { + columns.push("f_enabled_mark"); + casts.push("::integer"); + values.push(Some("1".to_string())); + } + if !obj.contains_key("sortCode") { + columns.push("f_sort_code"); + casts.push("::bigint"); + values.push(Some("0".to_string())); + } + // 🔴 `f_is_system` = 2(**自定义**)—— 官方 DDL 注释:1=系统,2=自定义。 + columns.push("f_is_system"); + casts.push("::integer"); + values.push(Some("2".to_string())); + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.account)); + columns.push("f_delete_mark"); + casts.push("::integer"); + values.push(Some("0".to_string())); + // 🔴 `f_creator_time` 用 SQL `now()` ⇒ **不占参数位**。 + columns.push("f_creator_time"); + let mut marks: Vec = (0..values.len()) + .map(|i| placeholder(i + 1, casts[i])) + .collect(); + marks.push("now()".to_string()); + let sql = format!( + "INSERT INTO base_standing ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建身份"); + } + ok(json!({ "id": new_id })) +} + +/// `PUT /api/permission/Standing/{id}` —— 改身份(**只 SET body 里出现的键**)。 +pub async fn standing_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_IDENTITY).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_standing \ + WHERE f_id = $1::text AND COALESCE(f_delete_mark,0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "身份查询"), + }; + if rows.is_empty() { + return fail(code::FAIL, "身份不存在"); + } + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in STANDING_WRITE_FIELDS { + if !obj.contains_key(json_key) { + continue; + } + values.push(value_to_text(obj.get(json_key))); + sets.push(format!("{} = ${}::text{}", column, values.len(), cast)); + } + if sets.is_empty() { + return ok(Value::Null); + } + values.push(Some(user.account)); + sets.push(format!("f_last_modify_user_id = ${}::text", values.len())); + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_standing SET {} WHERE f_id = ${}::text", + sets.join(", "), + values.len() + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "修改身份"); + } + ok(Value::Null) +} + +/// `DELETE /api/permission/Standing/{id}` —— 删身份(软删 + 解绑关联关系)。 +pub async fn standing_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_IDENTITY).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let values = [Some(user.account.clone()), Some(id.clone())]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_standing SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text WHERE f_id = $2::text \ + AND COALESCE(f_delete_mark,0) = 0", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "删除身份"); + } + // 关联关系同步软删(官方 `StandingServiceImpl.delete` 也删 `authorize`)。 + // 🔴 **参数必须与占位符逐字对齐**:`$1`=f_item_type('standing')、`$2`=f_item_id、 + // `$3`=删除人(写进审计列 `f_delete_user_id`,否则 PG 拒「无法确定参数类型」)。 + let rel = [ + Some(STANDING_ITEM_TYPE.to_string()), + Some(id), + Some(user.account), + ]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_authorize SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $3::text \ + WHERE f_item_type = $1::text AND f_item_id = $2::text \ + AND COALESCE(f_delete_mark,0) = 0", + ¶ms_of(&rel), + ) + .await + { + return db_error(e, "删除身份关联关系"); + } + ok(Value::Null) +} + +/// `GET /api/permission/Standing/list` —— 身份**关联列表**(该身份下挂的角色/岗位)。 +/// +/// 🔴 官方 `StandingController.lists`: +/// - `type=position` ⇒ 岗位(`base_position`);否则 ⇒ 角色(`base_role`); +/// - 关联关系落在 `base_authorize`:`f_item_id`=身份 id、`f_item_type`='standing'、 +/// `f_object_type`='role'/'position'、`f_object_id`=角色/岗位 id。 +pub async fn standing_relation_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_IDENTITY).await { + return resp; + } + let standing_id = crate::platform::sys::query_param(&raw, "id"); + let standing_id = standing_id.trim().to_string(); + let kind = crate::platform::sys::query_param(&raw, "type"); + let kind = kind.trim().to_string(); + let keyword = crate::platform::sys::query_param(&raw, "keyword"); + let keyword = keyword.trim().to_string(); + let page = Paging::of(&raw); + + if kind == STANDING_OBJECT_TYPE_POSITION { + // 岗位:本仓 `base_position` 已有 ⇒ 直接按 `base_authorize` 的关系取。 + let sql = format!( + "SELECT p.f_id AS \"id\", p.f_full_name AS \"fullName\", p.f_en_code AS \"enCode\", \ + p.f_description AS \"description\", \ + COALESCE(p.f_sort_code, 0) AS \"sortCode\", \ + 0 AS \"globalMark\", \ + COALESCE(p.f_enabled_mark, 0) AS \"enabledMark\", \ + 0 AS \"isSystem\", \ + 0 AS \"disable\" \ + FROM base_position p \ + JOIN base_authorize a \ + ON a.f_object_id = p.f_id AND a.f_object_type = '{STANDING_OBJECT_TYPE_POSITION}' \ + AND a.f_item_type = '{STANDING_ITEM_TYPE}' AND a.f_item_id = $1::text \ + AND COALESCE(a.f_delete_mark,0) = 0 \ + WHERE COALESCE(p.f_delete_mark,0) = 0 \ + ORDER BY p.f_sort_code ASC, p.f_full_name ASC" + ); + return match state.db.query_json_params(&sql, &[&standing_id]).await { + Ok(rows) => ok(page_list(1, rows.len().max(1) as i64, rows.len() as i64, rows)), + Err(e) => db_error(e, "身份岗位关联查询"), + }; + } + + // 角色:官方按 `base_role` 的 `f_global_mark` 判「系统身份」。 + let mut filters = vec![ + "a.f_item_type = 'standing'".to_string(), + "a.f_item_id = $1::text".to_string(), + "a.f_object_type = 'role'".to_string(), + "COALESCE(a.f_delete_mark,0) = 0".to_string(), + "COALESCE(r.f_delete_mark,0) = 0".to_string(), + ]; + let mut params: Vec> = vec![Some(standing_id.clone())]; + if !keyword.is_empty() { + filters.push("(r.f_full_name ILIKE $2::text OR r.f_en_code ILIKE $2::text)".to_string()); + params.push(Some(format!("%{keyword}%"))); + } + let where_sql = filters.join(" AND "); + let sql = format!( + "SELECT r.f_id AS \"id\", r.f_full_name AS \"fullName\", r.f_en_code AS \"enCode\", \ + r.f_description AS \"description\", \ + COALESCE(r.f_sort_code, 0) AS \"sortCode\", \ + COALESCE(r.f_global_mark, 0) AS \"globalMark\", \ + COALESCE(r.f_enabled_mark, 0) AS \"enabledMark\", \ + CASE WHEN COALESCE(r.f_global_mark, 0) = 1 THEN 1 ELSE 0 END AS \"isSystem\", \ + 0 AS \"disable\" \ + FROM base_role r JOIN base_authorize a ON a.f_object_id = r.f_id \ + WHERE {where_sql} \ + ORDER BY r.f_global_mark ASC, r.f_full_name ASC" + ); + match state.db.query_json_params(&sql, ¶ms_of(¶ms)).await { + Ok(rows) => ok(page_list( + page.current_page, + page.page_size, + rows.len() as i64, + rows, + )), + Err(e) => db_error(e, "身份角色关联查询"), + } +} + +/// `POST /api/permission/Standing/{id}/Actions/AddObject` —— 给身份加角色/岗位。 +/// +/// 🔴 官方 `StandingController.addObject`:body `{ids:[…], type:'role'|'position'}`; +/// 关系写 `base_authorize`(`f_item_id`=身份 id、`f_item_type`='standing')。 +pub async fn standing_add_object( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_IDENTITY).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let ids = id_list(&obj); + if ids.is_empty() { + return ok(Value::Null); + } + let kind = obj + .get("type") + .and_then(Value::as_str) + .unwrap_or(STANDING_OBJECT_TYPE_ROLE) + .trim() + .to_string(); + let object_type = if kind == STANDING_OBJECT_TYPE_POSITION { + STANDING_OBJECT_TYPE_POSITION.to_string() + } else { + STANDING_OBJECT_TYPE_ROLE.to_string() + }; + + // 幂等:已存在的关联跳过(官方 `addObject` 也是 `!authorizeList.contains(thisId)`)。 + let existing = match state + .db + .query_json_params( + "SELECT f_object_id AS \"id\" FROM base_authorize \ + WHERE f_item_type = $1::text AND f_item_id = $2::text \ + AND f_object_type = $3::text AND COALESCE(f_delete_mark,0) = 0", + &[&STANDING_ITEM_TYPE, &id, &object_type], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "身份关联查询"), + }; + let existing_ids: HashSet = existing + .iter() + .filter_map(|r| r["id"].as_str()) + .map(str::to_string) + .collect(); + + for object_id in ids { + if existing_ids.contains(&object_id) { + continue; + } + let new_row_id = new_uuid(); + let values = [ + Some(new_row_id), + Some(STANDING_ITEM_TYPE.to_string()), + Some(id.clone()), + Some(object_type.clone()), + Some(object_id), + Some(user.account.clone()), + ]; + // 🔴 `f_creator_time` 用 `now()` ⇒ 不占参数位。 + let sql = "INSERT INTO base_authorize \ + (f_id, f_item_type, f_item_id, f_object_type, f_object_id, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ + now(), 0, '0')"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "新增身份关联"); + } + } + ok(Value::Null) +} + +/// `POST /api/permission/Standing/{id}/Actions/DeleteObject` —— 从身份移除角色/岗位。 +pub async fn standing_delete_object( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_IDENTITY).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let ids = id_list(&obj); + if ids.is_empty() { + return ok(Value::Null); + } + let kind = obj + .get("type") + .and_then(Value::as_str) + .unwrap_or(STANDING_OBJECT_TYPE_ROLE) + .trim() + .to_string(); + let object_type = if kind == STANDING_OBJECT_TYPE_POSITION { + STANDING_OBJECT_TYPE_POSITION.to_string() + } else { + STANDING_OBJECT_TYPE_ROLE.to_string() + }; + + for object_id in ids { + let values = [ + Some(user.account.clone()), + Some(STANDING_ITEM_TYPE.to_string()), + Some(id.clone()), + Some(object_type.clone()), + Some(object_id), + ]; + let sql = "UPDATE base_authorize SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text \ + WHERE f_item_type = $2::text AND f_item_id = $3::text \ + AND f_object_type = $4::text AND f_object_id = $5::text \ + AND COALESCE(f_delete_mark,0) = 0"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "删除身份关联"); + } + } + ok(Value::Null) +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 5a715ee..a83097c 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -375,6 +375,60 @@ pub fn build_router(state: AppState) -> axum::Router { "/api/permission/Users/Current/{id}/saas", delete(jnpf::self_saas_exit), ) + // ---- 身份管理(`permission/Standing`)---- + // + // 🔴 **一条 `.route()` 只挂一个方法**(`check-contract-scan.py` 只解析第一个 + // 方法调用)⇒ 同路径的多方法必须写成**多条** `.route()`(axum 会合并)。 + .route("/api/permission/Standing", get(jnpf::standing_list)) + .route("/api/permission/Standing", post(jnpf::standing_create)) + .route("/api/permission/Standing/list", get(jnpf::standing_relation_list)) + .route("/api/permission/Standing/{id}", get(jnpf::standing_info)) + .route("/api/permission/Standing/{id}", put(jnpf::standing_update)) + .route("/api/permission/Standing/{id}", delete(jnpf::standing_delete)) + .route( + "/api/permission/Standing/{id}/Actions/AddObject", + post(jnpf::standing_add_object), + ) + .route( + "/api/permission/Standing/{id}/Actions/DeleteObject", + post(jnpf::standing_delete_object), + ) + // ---- 权限组(`permission/PermissionGroup`)---- + .route("/api/permission/PermissionGroup", get(jnpf::permission_group_list)) + .route( + "/api/permission/PermissionGroup", + post(jnpf::permission_group_create), + ) + .route( + "/api/permission/PermissionGroup/PermissionMember/{id}", + get(jnpf::permission_group_member_list), + ) + .route( + "/api/permission/PermissionGroup/PermissionMember/{id}", + post(jnpf::permission_group_member_save), + ) + .route( + "/api/permission/PermissionGroup/{id}", + get(jnpf::permission_group_info), + ) + .route( + "/api/permission/PermissionGroup/{id}", + put(jnpf::permission_group_update), + ) + .route( + "/api/permission/PermissionGroup/{id}", + delete(jnpf::permission_group_delete), + ) + .route( + "/api/permission/PermissionGroup/{id}/Actions/Copy", + post(jnpf::permission_group_copy), + ) + // ---- 动作管理(`permission/Action`)---- + .route("/api/permission/Action", get(jnpf::action_list)) + .route("/api/permission/Action", post(jnpf::action_create)) + .route("/api/permission/Action/{id}", get(jnpf::action_info)) + .route("/api/permission/Action/{id}", put(jnpf::action_update)) + .route("/api/permission/Action/{id}", delete(jnpf::action_delete)) // ---- 业务模块的路由(demo / shop / books)由业务层自带 ⇒ 这里只 merge ---- .merge(modules::router()); @@ -895,7 +949,7 @@ mod tests { let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); assert_eq!(body["ok"], true); - assert_eq!(body["tables"], 18); + assert_eq!(body["tables"], 21); assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); } @@ -910,7 +964,7 @@ mod tests { let port = serve(new_state(db().await)).await; // 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。 - const JNPF_REGISTERED: [&str; 99] = [ + const JNPF_REGISTERED: [&str; 110] = [ "/api/permission/Users", "/api/permission/Users/any-id", "/api/permission/Users/BatchDelete", @@ -1010,6 +1064,17 @@ mod tests { "/api/permission/Users/Current/saasTenantName/any-id", "/api/permission/Users/Current/saasjoin", "/api/permission/Users/Current/any-id/saas", + "/api/permission/Standing", + "/api/permission/Standing/list", + "/api/permission/Standing/any-id", + "/api/permission/Standing/any-id/Actions/AddObject", + "/api/permission/Standing/any-id/Actions/DeleteObject", + "/api/permission/PermissionGroup", + "/api/permission/PermissionGroup/any-id", + "/api/permission/PermissionGroup/any-id/Actions/Copy", + "/api/permission/PermissionGroup/PermissionMember/any-id", + "/api/permission/Action", + "/api/permission/Action/any-id", ]; for path in JNPF_REGISTERED { diff --git a/src/backend/tests/batch2_it.rs b/src/backend/tests/batch2_it.rs new file mode 100644 index 0000000..4b3ae39 --- /dev/null +++ b/src/backend/tests/batch2_it.rs @@ -0,0 +1,513 @@ +//! 批次 2(Standing / PermissionGroup / Action)集成测试。 +//! +//! 🔴 **本文件专门钉三个曾经真出过的 bug**(都是「接口返 200 / 500 但功能不对」这一类): +//! ① `GET /PermissionGroup/PermissionMember/{id}` 用 `f_id = ANY($1::text[])` ⇒ +//! pglite-rs 0.2.7 把 `$1::text[]` 当成 PG 数组类型 `_text` ⇒ 协议错 ⇒ 500 / data=null。 +//! 修法:改成 `f_id = ANY(string_to_array($1::text, ','))`(**函数在 SQL 里做** ⇒ 参数仍是 text)。 +//! ② `DELETE /PermissionGroup/{id}` 软删 `base_authorize` 的 SQL 带了 `$1`(删除人) +//! 但 WHERE/赋值里没真正用到 ⇒ PG 报 `42P18: could not determine data type of parameter $1`。 +//! 修法:把 `f_delete_user_id = $1::text` 写进 SET。 +//! ③ `DELETE /Standing/{id}` 软删关联的**占位符与参数顺序错位** +//! (SQL 用 `$1`=f_item_type、`$2`=f_item_id,参数却传 `[account, id]`) +//! ⇒ 软删删不掉 ⇒ 关联残留。 +//! +//! 🔴 另钉一处**官方形状偏差**:`PermissionGroup` 列表里的 `permissionMember` +//! 官方会用 `userService.getFullNameByIds` 把 id 串换成 **fullName 串**, +//! 本仓必须用子查询做同样的替换,否则前端拿到的是一串 uuid。 +//! +//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例 +//! ⇒ 全文件共用一个临时库(`OnceCell`),并用一把进程级 `Mutex` **整体串行化**。 +//! 🔴 **不依赖测试执行顺序**:每个测试用自己专属的字段值。 + +use std::path::PathBuf; +use std::sync::Arc; + +use serde_json::Value; +use ssw_platform::bootstrap::ensure_base; +use ssw_platform::platform::config::Config; +use ssw_platform::platform::db::Db; +use ssw_platform::platform::seed::first_seed; +use ssw_platform::platform::session::SessionStore; +use ssw_platform::platform::state::AppState; +use ssw_platform::routes::build_app; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::net::TcpStream; +use tokio::sync::{Mutex, OnceCell}; + +/// 全文件共享的临时库。 +static DB: OnceCell = OnceCell::const_new(); + +/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。 +static LOCK: Mutex<()> = Mutex::const_new(()); + +async fn db() -> &'static Db { + DB.get_or_init(|| async { + let db = Db::open_temp() + .await + .expect("打开 pglite 临时库失败"); + db.ensure_schema().await.expect("ensure_schema 失败"); + ensure_base(&db).await.expect("ensure_base 失败"); + first_seed(&db, "123456").await.expect("first_seed 失败"); + db + }) + .await +} + +/// 起一个真实 HTTP 服务(面 B:请求头带 `Vue-Version: 3`)。 +async fn serve(state: AppState) -> u16 { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0") + .await + .expect("绑定失败"); + let port = listener.local_addr().expect("取本地地址失败").port(); + let server = tokio::spawn(async move { + let _ = axum::serve(listener, build_app(state)).await; + }); + tokio::task::yield_now().await; + std::mem::forget(server); + port +} + +/// 发一次 HTTP 请求,返回 `(状态行, 响应体 JSON)`。 +/// +/// 🔴 请求头必须带 `Vue-Version: 3`(面 B 判别头)⇒ 走官方 JNPF 形状。 +async fn call( + port: u16, + method: &str, + path: &str, + token: &str, + body: Option<&str>, +) -> (String, Value) { + let mut stream = TcpStream::connect(("127.0.0.1", port)) + .await + .expect("连接失败"); + let payload = body.unwrap_or(""); + let req = format!( + "{method} {path} HTTP/1.1\r\n\ + Host: 127.0.0.1\r\n\ + Vue-Version: 3\r\n\ + App-Code: mainSystem\r\n\ + Authorization: {token}\r\n\ + Content-Type: application/json\r\n\ + Content-Length: {}\r\n\ + Connection: close\r\n\r\n{payload}", + payload.len() + ); + stream.write_all(req.as_bytes()).await.expect("写请求失败"); + let mut buf = Vec::new(); + tokio::time::timeout( + std::time::Duration::from_secs(10), + stream.read_to_end(&mut buf), + ) + .await + .expect("读响应超时") + .expect("读响应失败"); + let text = String::from_utf8_lossy(&buf).to_string(); + let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + let status = head.lines().next().unwrap_or_default().to_string(); + let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null); + (status, json) +} + +/// 登录拿 token(面 B)。 +async fn login(port: u16, account: &str, plain: &str) -> String { + let enc = ssw_platform::platform::cipher::encrypt_password(plain); + let payload = format!("account={account}&password={enc}"); + let mut stream = TcpStream::connect(("127.0.0.1", port)) + .await + .expect("连接失败"); + let req = format!( + "POST /api/oauth/Login HTTP/1.1\r\n\ + Host: 127.0.0.1\r\n\ + Vue-Version: 3\r\n\ + App-Code: mainSystem\r\n\ + Content-Type: application/x-www-form-urlencoded\r\n\ + Content-Length: {}\r\n\ + Connection: close\r\n\r\n{payload}", + payload.len() + ); + stream.write_all(req.as_bytes()).await.expect("写请求失败"); + let mut buf = Vec::new(); + tokio::time::timeout( + std::time::Duration::from_secs(10), + stream.read_to_end(&mut buf), + ) + .await + .expect("读响应超时") + .expect("读响应失败"); + let text = String::from_utf8_lossy(&buf).to_string(); + let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON"); + json["data"]["token"] + .as_str() + .expect("登录必须返回 token") + .to_string() +} + +/// 造状态(每个测试自己一份 ⇒ token 表互不干扰)。 +fn new_state(db: &Db) -> AppState { + AppState { + config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch2-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::new()), + } +} + +/// admin 的用户 id(种子里那个)。 +async fn admin_id(db: &Db) -> String { + let rows = db + .query_json( + "SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1", + ) + .await + .expect("读 admin 行失败"); + rows.first() + .and_then(|r| r["id"].as_str()) + .expect("admin 行必须存在") + .to_string() +} + +/// 🔴 **Bug ① 的钉子**:`GET /PermissionGroup/PermissionMember/{id}` 必须真的返出成员。 +/// +/// 曾用 `f_id = ANY($1::text[])` ⇒ pglite-rs 0.2.7 把它当成 PG 数组类型 `_text` +/// ⇒ 协议错 `cannot convert between the Rust type String and the Postgres type _text` +/// ⇒ 接口 500 / `data: null`。 +#[tokio::test] +async fn permission_member_list_returns_members() { + let _g = LOCK.lock().await; + let db = db().await; + let port = serve(new_state(db)).await; + let token = login(port, "admin", "123456").await; + + // 建一个权限组 + let tag = admin_id(db).await; + let (_, res) = call( + port, + "POST", + "/api/permission/PermissionGroup", + &token, + Some(&serde_json::json!({ + "fullName": format!("成员组-{tag}"), + "enCode": format!("mgroup-{}", &tag[..8]), + "sortCode": 1, + "description": "回归测试" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建权限组必须成功:{res}"); + let pgid = res["data"]["id"] + .as_str() + .expect("建权限组必须返 id") + .to_string(); + + // 建一个当成员的用户 + let acc = format!("b2member-{}", &tag[..8]); + let (_, res) = call( + port, + "POST", + "/api/permission/Users", + &token, + Some(&serde_json::json!({ + "account": acc, + "realName": format!("批次2成员-{tag}"), + "password": "123456" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建成员用户必须成功:{res}"); + let muid = res["data"]["id"] + .as_str() + .expect("建成员用户必须返 id") + .to_string(); + + // 存成员 + let (_, res) = call( + port, + "POST", + &format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"), + &token, + Some(&serde_json::json!({ "ids": [muid] }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "存权限组成员必须成功:{res}"); + + // 🔴 核心断言:列表必须真的返出 1 个成员(曾经是 data=null / 500) + let (_, res) = call( + port, + "GET", + &format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"), + &token, + None, + ) + .await; + assert_eq!(res["code"], 200, "查权限组成员必须成功:{res}"); + let list = res["data"]["list"] + .as_array() + .unwrap_or_else(|| panic!("data.list 必须是数组:{res}")); + assert_eq!( + list.len(), + 1, + "权限组必须返 1 个成员(曾经因 $1::text[] 数组类型协议错而 data=null):{res}" + ); + assert_eq!( + list[0]["fullName"].as_str(), + Some(format!("批次2成员-{tag}").as_str()), + "成员的 fullName 必须正确:{res}" + ); +} + +/// 🔴 **Bug ② 的钉子**:`DELETE /PermissionGroup/{id}` 必须成功(不能 500)。 +/// +/// 软删 `base_authorize` 的 SQL 曾带了 `$1`(删除人)但没用它 +/// ⇒ PG 报 `42P18: could not determine data type of parameter $1` ⇒ 500。 +#[tokio::test] +async fn permission_group_delete_succeeds() { + let _g = LOCK.lock().await; + let db = db().await; + let port = serve(new_state(db)).await; + let token = login(port, "admin", "123456").await; + + let tag = admin_id(db).await; + let (_, res) = call( + port, + "POST", + "/api/permission/PermissionGroup", + &token, + Some(&serde_json::json!({ + "fullName": format!("待删组-{tag}"), + "enCode": format!("delgroup-{}", &tag[..8]), + "sortCode": 2, + "description": "回归测试" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建权限组必须成功:{res}"); + let pgid = res["data"]["id"] + .as_str() + .expect("建权限组必须返 id") + .to_string(); + + let (_, res) = call( + port, + "DELETE", + &format!("/api/permission/PermissionGroup/{pgid}"), + &token, + None, + ) + .await; + assert_eq!( + res["code"], 200, + "删权限组必须成功(曾经因软删 SQL 里有未使用的 $1 而 500):{res}" + ); + + // 软删后再查详情必须查不到 + let (_, res) = call( + port, + "GET", + &format!("/api/permission/PermissionGroup/{pgid}"), + &token, + None, + ) + .await; + assert_eq!(res["code"], 400, "删完后详情必须查不到:{res}"); +} + +/// 🔴 **Bug ③ 的钉子**:`DELETE /Standing/{id}` 必须把**关联**一起软删干净。 +/// +/// 曾把 `base_authorize` 软删的占位符与参数顺序搞反(SQL `$1`=f_item_type、`$2`=f_item_id, +/// 参数却传 `[account, id]`)⇒ 关联残留 ⇒ 删完还能在 `/Standing/list` 里看到。 +#[tokio::test] +async fn standing_delete_clears_relations() { + let _g = LOCK.lock().await; + let db = db().await; + let port = serve(new_state(db)).await; + let token = login(port, "admin", "123456").await; + + // 取一个角色 id 当关联对象 + let rows = db + .query_json("SELECT f_id AS \"id\" FROM base_role LIMIT 1") + .await + .expect("读角色失败"); + let rid = rows + .first() + .and_then(|r| r["id"].as_str()) + .expect("必须有角色") + .to_string(); + + let tag = admin_id(db).await; + let (_, res) = call( + port, + "POST", + "/api/permission/Standing", + &token, + Some(&serde_json::json!({ + "fullName": format!("待删身份-{tag}"), + "enCode": format!("delstand-{}", &tag[..8]), + "sortCode": 3, + "description": "回归测试" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建身份必须成功:{res}"); + let sid = res["data"]["id"] + .as_str() + .expect("建身份必须返 id") + .to_string(); + + // 加一条角色关联 + let (_, res) = call( + port, + "POST", + &format!("/api/permission/Standing/{sid}/Actions/AddObject"), + &token, + Some(&serde_json::json!({ "ids": [rid], "type": "role" }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "加关联必须成功:{res}"); + + // 确认关联在 + let (_, res) = call( + port, + "GET", + &format!("/api/permission/Standing/list?id={sid}&type=role"), + &token, + None, + ) + .await; + let n = res["data"]["list"].as_array().map(|a| a.len()).unwrap_or(0); + assert_eq!(n, 1, "加完关联应有 1 条:{res}"); + + // 删身份 + let (_, res) = call( + port, + "DELETE", + &format!("/api/permission/Standing/{sid}"), + &token, + None, + ) + .await; + assert_eq!( + res["code"], + 200, + "删身份必须成功(曾经因软删关联的占位符错位而 500):{res}" + ); + + // 🔴 核心断言:关联必须也被软删干净 + // (`sid` 是我们刚建出来�� uuid ⇒ 直接字面量拼进 SQL,测试专用) + let sql = format!( + "SELECT COUNT(*) AS \"n\" FROM base_authorize \ + WHERE f_item_type = 'standing' AND f_item_id = '{sid}' \ + AND COALESCE(f_delete_mark,0) = 0" + ); + let rows = db.query_json(&sql).await.unwrap_or_else(|e| panic!("回读失败:{e}")); + let alive = rows + .first() + .and_then(|r| r["n"].as_i64()) + .unwrap_or(-1); + assert_eq!( + alive, 0, + "删身份后关联必须被软删干净(曾经因占位符与参数顺序错位而残留):{rows:?}" + ); +} + +/// 判断一个字符串是不是「裸 uuid」(uuid 形状:8-4-4-4-12 全是十六进制)。 +/// +/// 🔴 不能简单用 `contains('-')` 判断 —— 成员名里也可能带 `-`。 +fn is_uuid_like(s: &str) -> bool { + let parts: Vec<&str> = s.split('-').collect(); + if parts.len() != 5 { + return false; + } + let lens = [8usize, 4, 4, 4, 12]; + parts + .iter() + .zip(lens.iter()) + .all(|(p, l)| p.len() == *l && p.chars().all(|c| c.is_ascii_hexdigit())) +} + +/// 🔴 **官方形状偏差的钉子**:`PermissionGroup` 列表里的 `permissionMember` +/// 官方会用 `getFullNameByIds` 把 id 串换成 **fullName 串** ⇒ 前端拿到的是人名不是 uuid。 +#[tokio::test] +async fn permission_group_list_exposes_member_full_names() { + let _g = LOCK.lock().await; + let db = db().await; + let port = serve(new_state(db)).await; + let token = login(port, "admin", "123456").await; + + let tag = admin_id(db).await; + let member_name = format!("名单成员-{tag}"); + + let (_, res) = call( + port, + "POST", + "/api/permission/Users", + &token, + Some(&serde_json::json!({ + "account": format!("listmem-{}", &tag[..8]), + "realName": member_name, + "password": "123456" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建成员必须成功:{res}"); + let muid = res["data"]["id"] + .as_str() + .expect("建成员必须返 id") + .to_string(); + + let (_, res) = call( + port, + "POST", + "/api/permission/PermissionGroup", + &token, + Some(&serde_json::json!({ + "fullName": format!("名单组-{tag}"), + "enCode": format!("listgroup-{}", &tag[..8]), + "sortCode": 4, + "description": "回归测试" + }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "建权限组必须成功:{res}"); + let pgid = res["data"]["id"] + .as_str() + .expect("建权限组必须返 id") + .to_string(); + + let (_, res) = call( + port, + "POST", + &format!("/api/permission/PermissionGroup/PermissionMember/{pgid}"), + &token, + Some(&serde_json::json!({ "ids": [muid] }).to_string()), + ) + .await; + assert_eq!(res["code"], 200, "存成员必须成功:{res}"); + + // 读列表,定位本组,看 permissionMember 是人名还是 uuid 串 + let (_, res) = call( + port, + "GET", + "/api/permission/PermissionGroup", + &token, + None, + ) + .await; + assert_eq!(res["code"], 200, "查权限组列表必须成功:{res}"); + let list = res["data"]["list"] + .as_array() + .unwrap_or_else(|| panic!("data.list 必须是数组:{res}")); + let me = list + .iter() + .find(|x| x["id"].as_str() == Some(pgid.as_str())) + .unwrap_or_else(|| panic!("列表里必须能找到刚建的组:{res}")); + let pm = me["permissionMember"].as_str().unwrap_or(""); + assert_eq!( + pm, + member_name.as_str(), + "列表里的 permissionMember 必须是**用户名**(官方 getFullNameByIds 的替换),实际={pm:?}" + ); + assert!( + !is_uuid_like(pm), + "permissionMember 绝不能是 uuid 串(官方会换成 fullName),实际={pm:?}" + ); +}