diff --git a/.workbuddy/memory/2026-11-01.md b/.workbuddy/memory/2026-11-01.md new file mode 100644 index 0000000..8e33007 --- /dev/null +++ b/.workbuddy/memory/2026-11-01.md @@ -0,0 +1,46 @@ +# 2026-11-01 + +## 面 B 批次 5 —— 系统日志 + 审批常用语 + 单据规则(21 条) + +新增 `base_sys_log`(30 列) / `base_common_words` / `base_bill_rule`,tables **29 → 32**; +`routes.rs` 加 22 条路由、`FACE_B_REGISTERED` 147 → **162**;`docs/contract.md` `[FACE] B 196 → 219`。 + +### 踩到的坑(都写进了 HANDOFF §1「批次 5」) + +- **登录日志此前根本不存在**:个人中心 `Users/Current/SystemLog` 是手写的恒空分页。 + 修法是把写入放进 `auth.rs::login_handler`(成功 `f_login_mark=1`、失败 0 + 原因进 `f_description`), + 再让 `Log?category=1` 与 `self_system_log` **共用同一个 `log_page(.., 1, Some(uid))`** ⇒ 两处同时变真。 + **写日志失败只打 stderr,绝不冒泡**(日志写坏了不能把登录搞挂)。 +- **`DELETE /Log/{type}` 的 `{type}` 是分类号(1 登录/2 访问/3 操作/4 异常/5 请求),不是记录 id。** + 实现成「删某一条」的话管理员点「一键清空」会静默无事发生。 + `Log/{id}` 上 GET(详情)与 DELETE(清空)同段名 —— matchit 不允许同位置两个参数名。 +- **`to_char` 占位符不能照搬官方**:PG 的 `HH` 是 12 小时制、毫秒叫 `MS` 不是 `SSS` + ⇒ 写了 `to_char_pattern()` 做映射,否则生成「下午 03 点」的错号。 +- **改单据规则只在四条件变化时清流水**:前缀/后缀**长度**、`f_digit`、`f_date_format`。 + 照抄官方判断,否则「改个描述」也清 `f_this_number` ⇒ 已发号重号。 +- **`f_this_number`/`f_output_number` 只由 `BillNumber` 回写**,不进 `*_WRITE_FIELDS`(14 列); + `f_output_number` 非空 ⇒ 禁删(`400 单据已经被使用,不允许被删除`)。 +- **常用语判重按「文本 + 类型」同档**(公共/个人各一套);官方 `CommonWordsController` 一个 + `@SaCheckPermission` 都没有 ⇒ 故意不挂 `guard()`,只 `require_login_face_b`(常量 `EN_COMMON_WORDS` + 因此删掉,否则 dead_code)。 +- `random_chunk` 用 uuid 字节做 xorshift 种子,**不引随机库**(避免给内核加依赖)。 +- 顺手修:`GET /api/system/DictionaryData/All` 原先**恒空**(下拉全空且不报错) + ⇒ 真读 `base_dictionary_type` + `base_dictionary_data`,`seed.rs` 灌 `businessType` 13 行(`isTree=0`)。 + 形状严格对齐官方 `allBindDictionary`:`{id,enCode,isTree,dictionaryList}`,**没有 `fullName`**。 + +### 已知 partial(刻意不假装成功) + +- `DELETE /Log/{id}` 的 `dataInterfaceId` 收窄未做。 +- `BillRule` 的 `Export` / `Import` 恒业务失败(本仓没有文件服务)。 + +### 数字(批次 5 收尾) + +`cargo test --workspace` **508**(+6)| `fe-gap` **215/900 = 23.9%**(system **84/196 = 42.9%**) +| 契约端点 **249 条(面 B 219)** | 官方覆盖 **238/245(implemented 225 / partial 13 / absent 7)** +| 十二道闸门全绿(check-contract PASS=10 FAIL=0)| 空载内存 7 MB + +### 下一个(批次 6) + +`DataModel/{}/Tables`(被 12 个页面共用,收益最高);其次 `extend`(53) / `systemData`(91), +但这两块多半是「本仓没这个模块」的恒空 stub,先看 §0-bis 的判断再动手。 +`visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。 diff --git a/HANDOFF.md b/HANDOFF.md index 965ec54..502f262 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -1,6 +1,6 @@ # HANDOFF —— 交给下一个 session 的现场交接 -> 更新于 2026-10-31 09:00。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), +> 更新于 2026-11-01(面 B 批次 5 收尾)。**开工先读这一页**(尤其 §0-bis 缺口全景),再读 `CLAUDE.md`(硬约定), > 最后看 `.workbuddy/memory/` 最近一天的日志(踩过的坑)。 > 无人值守时不要问用户,选最保守可行的方案继续,并把决策写回本文件。 @@ -48,18 +48,33 @@ `BusinessCategory/treeList`(9 ✅批次4) / `Log`(9) / `workflow/operator/List`(9) / `Dataset/{}/Actions/InfoByIds`(9) / `BasicDataType`(9) / `extend/TableExample` 四个(9) / `Tag/selector`(8 ✅批次3)。 -**下一个(批次 5)建议**:`system/Log`(5) + `system/CommonWords`(6) + `system/BillRule`(8) -—— 都是「一张表 + CRUD + selector」,模板照抄;`Log` 还能顺手把登录日志落库, -让个人中心的 `Users/Current/SystemLog`(目前恒空)变成真的。 +~~**下一个(批次 5)建议**:`system/Log`(5) + `system/CommonWords`(6) + `system/BillRule`(8)~~ +✅ **批次 5 做完(实际 21 条)**——新表 `base_sys_log` / `base_common_words` / `base_bill_rule`; +登录即落日志(`Log` 页与个人中心「登录日志」同一份数据)、审批常用语 CRUD + 使用计数、 +单据规则 CRUD + **单号生成器**(时间/随机/UUID 三分支 + 跨天归零 + 回写流水)。 +顺手把 `DictionaryData/All` 从「恒空」改成真读字典 + 灌 `businessType` 13 行种子。 +详见 §1「批次 5」小节。 -**2026-10-31 实测**(`python3 scripts/fe-gap.py`):合计 **197 / 900**(21.9%); -`permission` 111/137(81.0%)、`system` **66/196(33.7%,批次 4 从 47 涨到 66)**; +**下一个(批次 6)建议**:`DataModel/{}/Tables`(12 页共用,最高优先) + +`extend`/`systemData` 那几个恒空 stub;`visualdev/OnlineDev/{}/Config`(10) 属低代码域,后置。 + +**2026-11-01 实测**(`python3 scripts/fe-gap.py`):合计 **215 / 900**(23.9%); +`permission` 111/137(81.0%)、`system` **84/196(42.9%,批次 4 47→66、批次 5 66→84)**; 剩下体量最大的仍是 `workFlow`(104) / `onlineDev`(101) / `systemData`(91) / `aiCenter`(75) / `extend`(64) / `msgCenter`(50) —— **基本都属于「本仓没这个模块」**。 --- -## 1. 一句话现状(2026-10-31 10:00 批次 2 + P0 拆分首批) +## 1. 一句话现状(2026-11-01 批次 5 收尾) + +**📌 当前数字(以此为准,下面各批的「当时数字」仅存档)**: + +- 契约端点 **249 条**(面 A 28 + 面 B **219** + 两面共用 2);`tables` → **32**。 +- `cargo test --offline --workspace` = **508 passed / 0 failed**。 +- 十二道闸门全绿;`check-contract` `PASS=10 FAIL=0`,官方端点覆盖 **238/245** + (implemented 225 / partial 13 / absent 7)。 +- `python3 scripts/fe-gap.py`:合计 **215 / 900(23.9%)**,`permission` 111/137(81.0%)、 + `system` **84/196(42.9%)**。 **✅ 后端已拆成 workspace 多 crate,业务包可独立编译;八道闸门全绿;空载内存 7 MB。** @@ -77,7 +92,7 @@ - 登录 `admin/123456` → 进 `/home` → `/permission/user` 正常渲染,左侧分组树 + 右侧表格有数据, **整页零非 200 请求**(fetch/XHR 双钩子实测 `[]`)。 - 机构管理 `/permission/organize` 也正常渲染(空状态,零报错)。 -**第二波(04:00–05:00)又干了一批,现在数字是这样:** +**第二波(04:00–05:00)当时的数字(已过期,仅存档):** - 契约端点 **207 条**(面 B **177** 条);`tables` → **26**(新增 `base_group`、 `base_position`、`base_dictionary_type`、`base_dictionary_data`、`base_user_extra`、 @@ -166,6 +181,35 @@ - 回归测试 `tests/batch4_it.rs`(**3 条**):分类树/裁剪/两段式 selector/判重、 发布扩散、读+回执+删除(含「已回执不回退」与「只删自己的」)。 +### 批次 5(2026-11-01)—— 系统日志 + 审批常用语 + 单据规则 + +**21 条面 B 端点**:`/api/system/Log`(6:列表/详情/删一条/按类型清空/清登录日志/模块名) ++ `/api/system/CommonWords`(7:列表/selector/详/增/改/删/使用计数) ++ `/api/system/BillRule`(10:列表/selector/详/增/改/启停/删/导出/导入/生成单号)。 + +- 新表三张(官方 DDL 逐字):`base_sys_log`(30 列)/ `base_common_words` / `base_bill_rule`;tables 29 → **32**。 +- 🔴 **登录日志此前根本不存在**:`self_system_log`(个人中心「登录日志」)是手写的恒空分页。 + 本轮在 `auth.rs::login_handler` 里落一行 `f_type=1`(成功 `f_login_mark=1`、失败 `=0` 且 `f_description` 存失败原因), + **失败只打 stderr 绝不冒泡**(日志写坏了不能把登录搞挂)⇒ `Log?category=1` 与 `Users/Current/SystemLog` + 共用同一个 `log_page(.., 1, Some(uid))`,两处同时变真。 +- 🔴 **`DELETE /Log/{type}` 的 `{type}` 是分类号不是 id**(官方 `deleteLoginLog` 就是删 `f_type=1` 全部)。 + 实现成「删某一条」的话,管理员点「一键清空」会静默什么都不做。路由上 `/Log/{id}` 的 GET(详情)与 DELETE(清空) + 共用同一段名 `{id}`(matchit 不允许同位置两个参数名),handler 内部按分类号解析。 +- 🔴 **`to_char` 的占位符不能照搬官方**:PG 的 `HH` 是 12 小时制、毫秒叫 `MS` 不叫 `SSS` + ⇒ 单独写 `to_char_pattern()` 把小写官方格式映射成 PG 格式,否则会生成「下午 03 点」的错号。 +- 🔴 **改单据规则时只有四个条件变了才清流水**(前缀/后缀**长度**、位数、日期格式)—— + 照抄官方这段判断,不然「改个描述」也会把 `f_this_number` 清掉,已发出的号就重号了。 +- 🔴 **`f_this_number` / `f_output_number` 只由 `BillNumber` 回写**,不在 `*_WRITE_FIELDS` 里(14 列不含这两个); + 规则被发过号(`f_output_number` 非空)就**禁删**(`400 单据已经被使用,不允许被删除`)。 +- 🔴 **常用语判重按 `文本 + 类型` 同档**(公共/个人各一套),且 `CommonWordsController` 官方**一个 + `@SaCheckPermission` 都没有** ⇒ 故意不挂 `guard()`,只做 `require_login_face_b`。 +- 已知 `partial`:`DELETE /Log/{id}` 的 `dataInterfaceId` 收窄未做;`BillRule` 的 `Export`/`Import` + 恒业务失败(本仓没有文件服务,**刻意不假装成功**)。 +- 顺手修:`GET /api/system/DictionaryData/All` 原先**恒空**(`businessType` 之类下拉全空且不报错) + ⇒ 改为真读两张字典表 + `seed.rs` 灌 `businessType` 13 行(`isTree=0`)。 +- 回归测试 `tests/batch5_it.rs`(**6 条**):登录落日志双读者一致、三条删除路径语义不同、 + 常用语 CRUD + 计数、单号时间格式 + 跨天归零、规则守卫、随机/UUID 分支。 + ### 🔴 上一批(第一批)踩到并解决的 4 个真 bug 1. `CurrentUser` 的 `preferenceJson` 必须是**字符串** `"{}"` —— 给对象会让前端 @@ -188,7 +232,7 @@ 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":21,...} +curl -s http://127.0.0.1:30000/api/health # 期望 {"ok":true,"tables":32,...} ``` 拿 token(面 B): @@ -315,7 +359,14 @@ xop run --secret GU=git_local_user --secret GP=git_local_pass -- bash -c ' 3. ~~`system/System`(11) + `system/SysConfig`(6) 系统配置页~~ ← **下一个** ✅ **批次 3 做完(实际 31 条,含 Tag)**——新表 `base_system_top` / `base_sys_config`; 应用中心 CRUD + 置顶 + 应用授权 + 系统参数/第三方配置键值表 + 管理员设置 + 同步统计。 -4. `message`(53) / `file`(32) / `extend`(53) / 低代码模块 ⇒ **批量恒空 stub** ← **下一个** +4. ~~`message`(53) 里的 `api/system/message.ts` 那 14 条~~ + ✅ **批次 4 做完(实际 19 条,含 BusinessCategory)**——新表 `base_business_category` / + `base_message` / `base_notice`。`api/msgCenter/*`(36 条运维后台)仍未定。 +5. ~~`system/Log`(5) + `system/CommonWords`(6) + `system/BillRule`(8)~~ + ✅ **批次 5 做完(实际 21 条)**——新表 `base_sys_log` / `base_common_words` / `base_bill_rule`; + 登录落日志 + 常用语 CRUD + 单据规则与单号生成器。 +6. `DataModel/{}/Tables`(12 页共用) / `extend`(53) / `systemData`(91) / `file`(32) / 低代码模块 + ⇒ **下一个**(`file` / `extend` / 低代码多半是恒空 stub,见 §0-bis 的判断) **实现模板(照抄就行)**:`ORGANIZE_WRITE_FIELDS` / `POSITION_WRITE_FIELDS` 那一套 —— 列白名单 + `now()` 不占参数位 + 只 SET body 里出现的键 + 读回不选 `f_password`。 diff --git a/PLAN.md b/PLAN.md index d443a87..54e8061 100644 --- a/PLAN.md +++ b/PLAN.md @@ -251,7 +251,7 @@ ssw-platform/ | 能力 | 现状 | 目标 | 差距 | |---|---|---|---| -| 面 B 契约端点 | ✅ 196 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | +| 面 B 契约端点 | ✅ 219 条 | 全量(含 lowcode/flow/file/message) | 补 ~250 条(多在 lowcode 域) | | `base_*` DDL | ✅ 21 张逐字对齐 | 全量 331 张中的必需集 | 按域补 | | 平台/业务分层 | ✅ `check-boundary.sh` 钉住 | 升级为 crate 级隔离 | **P0 已拆 contract / store / sdk;asset 包可独立编译;`jnpf.rs`→`face_b.rs`** | | 低代码元数据引擎 | ✅ **P2-b 完成**:解析 + 校验 + 建表 + 动态 CRUD(6 个工具) | visualdev 同构 + 动态 CRUD + 发布 | 读 release / 单据号 / 乐观锁 → P2-c | diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index 6078b43..f0f1498 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -1203,29 +1203,30 @@ mod tests { #[test] fn schema_sql_has_expected_table_count() { - // schema.sql 必须包含 29 张表的 CREATE TABLE - // (24 张 base_*:8 张官方 + base_system + base_group + base_position + // schema.sql 必须包含 32 张表的 CREATE TABLE + // (27 张 base_*:8 张官方 + base_system + base_group + base_position // + 字典分类/字典数据 + base_sign_img + base_user_extra // + base_standing + base_permission_group + base_action // + base_system_top + base_sys_config(应用中心/系统配置)+ base_tag(标签) // + base_business_category + base_message + base_notice(消息批次) + // + base_sys_log / base_common_words / base_bill_rule(日志与模板中心批次) // + base_visual_dev / base_visual_release(P2 低代码),+ 4 张业务表)。 // // 🔴 这个数字**故意写死**:加表必须同时改这里与 main.rs 的 BASE_TABLES, // 两处都改才算登记完成(漏一处就是「孤儿 DDL」或「白名单多一项」)。 let count = SCHEMA_SQL.matches("CREATE TABLE ").count(); - assert_eq!(count, 29, "schema.sql 的 CREATE TABLE 数量应为 29"); + assert_eq!(count, 32, "schema.sql 的 CREATE TABLE 数量应为 32"); } /// 🔴 [`ddl_tables`] 的解析必须与上面那条计数一致(不能只数到 12 却解析出别的)。 #[test] fn ddl_tables_parses_every_create_table() { let tables = ddl_tables(); - assert_eq!(tables.len(), 29, "ddl_tables 应解析出 29 张表"); + assert_eq!(tables.len(), 32, "ddl_tables 应解析出 32 张表"); assert!(tables.iter().all(|t| !t.is_empty())); assert_eq!( tables.iter().collect::>().len(), - 29, + 32, "表名不许重复" ); // 基础 base_* 必须都在(业务表由业务层 spec 派生,不在本文件写死)。 @@ -1244,6 +1245,9 @@ mod tests { "base_business_category", "base_message", "base_notice", + "base_sys_log", + "base_common_words", + "base_bill_rule", ] { assert!( tables.iter().any(|t| t == base), diff --git a/docs/contract.md b/docs/contract.md index 3997831..23a3b02 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -1351,6 +1351,29 @@ 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 +B GET /api/system/Log sysLog.loginLog platform +B DELETE /api/system/Log sysLog.loginLog platform +B DELETE /api/system/Log/deleteLoginLog 登录 platform +B GET /api/system/Log/ModuleName sysLog.loginLog platform +B GET /api/system/Log/{id} sysLog.loginLog platform +B DELETE /api/system/Log/{id} sysLog.loginLog platform +B GET /api/system/CommonWords 登录 platform +B POST /api/system/CommonWords 登录 platform +B GET /api/system/CommonWords/Selector 登录 platform +B POST /api/system/CommonWords/UsesNum 登录 platform +B GET /api/system/CommonWords/{id} 登录 platform +B PUT /api/system/CommonWords/{id} 登录 platform +B DELETE /api/system/CommonWords/{id} 登录 platform +B GET /api/system/BillRule templateCenter.billRule platform +B POST /api/system/BillRule templateCenter.billRule platform +B GET /api/system/BillRule/Selector templateCenter.billRule platform +B GET /api/system/BillRule/BillNumber/{enCode} 登录 platform +B POST /api/system/BillRule/Actions/Import templateCenter.billRule platform +B GET /api/system/BillRule/{id} templateCenter.billRule platform +B PUT /api/system/BillRule/{id} templateCenter.billRule platform +B DELETE /api/system/BillRule/{id} templateCenter.billRule platform +B PUT /api/system/BillRule/{id}/Actions/State templateCenter.billRule platform +B GET /api/system/BillRule/{id}/Actions/Export templateCenter.billRule 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 @@ -1367,7 +1390,7 @@ A DELETE /api/ssw/asset/DataResource/Delete asset/DataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 196 面 B 专属(官方 JNPF 形状) +B 219 面 B 专属(官方 JNPF 形状) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -1471,7 +1494,7 @@ DELETE /api/message/Notice/{id} implemented NoticeController.java:221 面 B 已 PUT /api/message/Notice/{id}/Actions/Release implemented NoticeController.java:239 面 B 已落地:置已发送 + **逐收件人落 `base_message`**(收件人为空 ⇒ 全体用户) GET /api/message/Notice/{id}/ReplyUserList implemented NoticeController.java:317 面 B 已落地:ListVO;按 `f_body_text LIKE %noticeId%` + `f_is_read = 2` 去重成人 DELETE /api/permission/socials/{id} implemented socialsUser.ts:21 面 B 已落地:本仓无 `base_socials_users` 表 ⇒ 无绑可解,恒成功(只返 msg) -GET /api/system/DictionaryData/All implemented dictionary.ts:38-40 面 B 已落地:恒 `{list:[]}`(无 base_dictionary 表);前端 `store/base.ts:48` 取 `res.data.list` ⇒ 不能是裸数组 +GET /api/system/DictionaryData/All implemented dictionary.ts:38-40 面 B 已落地:`{list:[{id,enCode,isTree,dictionaryList}]}`(`isTree=1` 的类型里 dictionaryList 是树);前端 `store/base.ts:48` 取 `res.data.list` ⇒ 不能是裸数组;`businessType` 字典由 `seed.rs` 灌 1 分类 + 13 数据行 GET /api/system/HomeData implemented homeData.ts:8 面 B 已落地:恒 `[]`(前端 `dashboard/index.vue:104` 读 `res.data.length` ⇒ 必须是数组) POST /api/system/MenuData/useModuleNum/{id} implemented collectMenu.ts:21 面 B 已落地:常用菜单计数**无表可记** ⇒ 恒成功(每页 afterEach 都调,404 会弹红条) GET /api/oauth/getLoginConfig implemented user.ts:33 面 B 已落地:恒 `{}`(**登录前**调用 ⇒ 无守卫;前端读 `res.data.redirect` ⇒ 必须是对象) @@ -1611,6 +1634,29 @@ POST /api/permission/Action implemented action.ts:13 `f_type` 强制 1(自定 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 软删 +GET /api/system/Log implemented LogController.java:62 面 B 已落地:PageListVO;`category` 1登录/3操作/4异常/5请求,其余(含 2 访问)按官方 `default` 返 `400`;`creatorTime` 是**毫秒数**(官方 `LoginLogVO.creatorTime` 是 `Long`) +DELETE /api/system/Log implemented LogController.java:115 面 B 已落地:body `{ids}`(数组或逗号串都收)⇒ 物理删;空 ids 返 `400` +GET /api/system/Log/{id} implemented LogController.java:96 面 B 已落地:详情(四个 VO 字段的并集) +DELETE /api/system/Log/{id} partial LogController.java:133 面 B 已落地:`{id}` 在官方是**分类号**(一键清空该分类),不是日志 id;`dataInterfaceId` 收窄未做 +DELETE /api/system/Log/deleteLoginLog implemented LogController.java:144 面 B 已落地:只删**当前用户**的登录日志(官方 `deleteHandleLog("1", 1, null)`);登录即可用(无点权限码) +GET /api/system/Log/ModuleName implemented LogController.java:156 面 B 已落地:裸数组 `[{moduleName}]`(不是 ListVO) +GET /api/system/CommonWords implemented CommonWordsController.java:61 面 B 已落地:PageListVO;`commonWordsType=1`(个人)时**额外**加 `f_creator_user_id=当前用户` 并按 `f_uses_num` 倒序 +GET /api/system/CommonWords/{id} implemented CommonWordsController.java:76 面 B 已落地:详情并补 `systemNames`(本仓无多应用授权 ⇒ 空串) +GET /api/system/CommonWords/Selector implemented CommonWordsController.java:105 面 B 已落地:ListVO;`type` 空 ⇒ 全部启用项 +POST /api/system/CommonWords implemented CommonWordsController.java:119 面 B 已落地:`text + type` 同档判重 ⇒ `400 常用语已存在`(`SYS105`) +PUT /api/system/CommonWords/{id} implemented CommonWordsController.java:139 面 B 已落地:只 SET body 出现的键;判重排除自身 +DELETE /api/system/CommonWords/{id} implemented CommonWordsController.java:159 面 B 已落地:软删 +POST /api/system/CommonWords/UsesNum implemented CommonWordsController.java:172 面 B 已落地:按**文本**累加 `f_uses_num`(官方就是按文本,不是按 id) +GET /api/system/BillRule implemented BillRuleController.java:84 面 B 已落地:PageListVO;`category` 用 `base_dictionary_data` 换成中文名,`creatorUser` = `姓名/账号` +GET /api/system/BillRule/Selector implemented BillRuleController.java:112 面 B 已落地:**也是 PageListVO**(官方 `ActionResult.page`),只给 `enabledMark=1` +PUT /api/system/BillRule/{id}/Actions/State implemented BillRuleController.java:143 面 B 已落地:`f_enabled_mark` 1↔0 来回切 +PUT /api/system/BillRule/{id} implemented BillRuleController.java:170 面 B 已落地:只 SET body 出现的键;**生成规则变了(前缀/后缀长度、位数、日期格式)⇒ 清空 `f_this_number`/`f_output_number`** +GET /api/system/BillRule/{id} implemented BillRuleController.java:211 面 B 已落地:详情(`category` 原样返 **id**,表单回填要用) +GET /api/system/BillRule/BillNumber/{enCode} implemented BillRuleController.java:227 面 B 已落地:三分支(时间格式/随机数/UUID)+ **跨天归零** + 回写流水号;登录即可用(官方无点权限码) +POST /api/system/BillRule implemented BillRuleController.java:243 面 B 已落地:名称/编码各自判重 ⇒ `400 名称不能重复` / `400 编码不能重复` +DELETE /api/system/BillRule/{id} implemented BillRuleController.java:267 面 B 已落地:`f_output_number` 非空 ⇒ `400 单据已经被使用,不允许被删除`(`SYS003`);否则软删 +GET /api/system/BillRule/{id}/Actions/Export partial BillRuleController.java:291 面 B 已落地但**恒失败**:官方走 `DataFileExport` 写文件服务,本仓无文件服务 ⇒ `400` + 人话(不假装成功) +POST /api/system/BillRule/Actions/Import partial BillRuleController.java:310 面 B 已落地但**恒失败**:同上,multipart 导入依赖文件服务 ⇒ `400` + 人话 [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 7853999..7cecd0d 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -608,6 +608,105 @@ CREATE TABLE base_notice ( PRIMARY KEY (f_id, f_tenant_id) ); +-- 系统日志(`/api/system/Log` + 个人中心「登录日志」)—— 列与官方 JNPF 7.0 逐字一致 +-- (官方 database/PostgreSQL/JNPF-PostgreSQL.sql `base_sys_log`)。 +-- 🔴 **一张表装五种日志**,靠 `f_type` 区分:1 登录 / 2 访问 / 3 操作 / 4 异常 / 5 请求 +-- (官方 `LogController.getInfoList` 的 `switch(pagination.getCategory())`)。 +-- 🔴 `f_creator_time` 在这里**就是日志时间**(官方没有单独的 `f_login_time`)。 +-- 🔴 `f_login_mark`:1 成功 / 0 失败;`f_login_type`:0 登录 / 1 退出 +-- (`views/sysLog/loginLog/index.vue:26-28` 的取值)。 +CREATE TABLE base_sys_log ( + f_id VARCHAR(50) NOT NULL, + f_user_id VARCHAR(50), + f_user_name VARCHAR(100), + f_type INTEGER, + f_level INTEGER, + f_ip_address VARCHAR(50), + f_ip_address_name VARCHAR(50), + f_request_url VARCHAR(500), + f_request_method VARCHAR(50), + f_request_duration INTEGER, + f_json TEXT, + f_plat_form VARCHAR(500), + 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_module_id VARCHAR(50), + f_module_name VARCHAR(50), + f_object_id VARCHAR(50), + f_description VARCHAR(500), + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + f_browser VARCHAR(50), + f_request_param TEXT, + f_request_target TEXT, + f_login_mark INTEGER, + f_login_type INTEGER, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 审批常用语(`/api/system/CommonWords`)—— 列与官方 JNPF 7.0 逐字一致。 +-- 🔴 `f_common_words_type`:0 公共(列表页 `searchInfo.commonWordsType`)/ 1 个人 +-- (官方在 `type=1` 时**额外**加 `f_creator_user_id = 当前用户`,并按 `f_uses_num` 倒序)。 +-- 🔴 `f_system_ids` 是**逗号串**(不是关联表):一个常用语可挂多个应用。 +CREATE TABLE base_common_words ( + f_id VARCHAR(50) NOT NULL, + f_system_ids VARCHAR(4000), + f_common_words_text VARCHAR(4000), + f_common_words_type INTEGER, + f_sort_code BIGINT, + 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_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_uses_num BIGINT, + PRIMARY KEY (f_id, f_tenant_id) +); + +-- 单据规则(`/api/system/BillRule` + `/BillNumber/{enCode}`)—— 列与官方 JNPF 7.0 逐字一致。 +-- 🔴 `f_type`:1 时间格式 / 2 随机数编号 / 3 UUID(官方 `getNumber` 三分支); +-- 时间格式分支还要 `f_date_format` + `f_digit` + `f_start_number` + `f_suffix`。 +-- 🔴 `f_this_number` / `f_output_number` 是**生成器状态**:每发一个号就 +1 并回写, +-- 所以删规则时官方要求 `f_output_number` 为空(`SYS003 已生成过流水号,不能删除`)。 +CREATE TABLE base_bill_rule ( + f_id VARCHAR(50) NOT NULL, + f_full_name VARCHAR(200), + f_en_code VARCHAR(200), + f_prefix VARCHAR(50), + f_date_format VARCHAR(50), + f_digit INTEGER, + f_start_number VARCHAR(50), + f_example VARCHAR(100), + f_this_number INTEGER, + f_output_number VARCHAR(100), + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_category VARCHAR(50), + 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_random_digit INTEGER, + f_random_type INTEGER, + f_suffix VARCHAR(50), + PRIMARY KEY (f_id, f_tenant_id) +); + -- ============================================================================ -- 业务表 3 张(demo_item / shop_product / book_shop_book) -- diff --git a/src/backend/src/main.rs b/src/backend/src/main.rs index 8421395..d1df0fc 100644 --- a/src/backend/src/main.rs +++ b/src/backend/src/main.rs @@ -44,8 +44,9 @@ use ssw_platform::routes; /// 承载 `App-Code` → `systemId` 的映射);P2 低代码新增 `base_visual_dev` / /// `base_visual_release`(功能定义与发布快照);应用中心/系统配置批次新增 /// `base_system_top` / `base_sys_config` / `base_tag`;消息批次新增 -/// `base_business_category` / `base_message` / `base_notice`,故清单现在是 **25 张**。 -const BASE_TABLES: [&str; 25] = [ +/// `base_business_category` / `base_message` / `base_notice`;日志与模板中心批次新增 +/// `base_sys_log` / `base_common_words` / `base_bill_rule`,故清单现在是 **28 张**。 +const BASE_TABLES: [&str; 28] = [ "base_group", "base_user", "base_role", @@ -72,6 +73,10 @@ const BASE_TABLES: [&str; 25] = [ "base_business_category", "base_message", "base_notice", + // 🔴 日志与模板中心批次(2026-11-01):系统日志 + 审批常用语 + 单据规则。 + "base_sys_log", + "base_common_words", + "base_bill_rule", // 🔴 低代码两张表是**平台表**不是业务表:它们存的是「功能定义」, // 任何业务模块都会用,属于引擎基础设施。 "base_visual_dev", diff --git a/src/backend/src/platform/auth.rs b/src/backend/src/platform/auth.rs index aefcc71..d2fa4cf 100644 --- a/src/backend/src/platform/auth.rs +++ b/src/backend/src/platform/auth.rs @@ -19,6 +19,7 @@ use axum::Json; use serde_json::{json, Value}; use crate::platform::cipher::decrypt_to_md5; +use crate::platform::db::pglite::ToSql; use crate::platform::envelope::{fail, ok, ActionResult}; use crate::platform::permission::{build_menu_list, has_module}; use crate::platform::session::TokenUser; @@ -152,8 +153,162 @@ pub async fn login_from_bytes(state: &AppState, body: Bytes) -> Json, body: Bytes) -> Json { - login_from_bytes(&state, body).await +/// +/// 🔴 比 [`login_from_bytes`] 多收一个 `HeaderMap`:登录成功/失败都要落一条 +/// `base_sys_log`(`f_type = 1`),而 IP / 浏览器 / 操作系统**只能从请求头拿**。 +/// 官方 `LogController` 的「登录日志」页与个人中心的 `Users/Current/SystemLog` +/// 都读它 —— 不写这张表,两个页面永远是空的(而且**不报错**)。 +pub async fn login_handler( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + // 先留一份账号:`login_from_bytes` 会把 body 消费掉,事后就拿不到了。 + let account = serde_urlencoded::from_bytes::(&body) + .ok() + .and_then(|form| form.account) + .unwrap_or_default(); + let resp = login_from_bytes(&state, body).await; + // 🔴 只在**有账号**时记账(连账号都没带 ⇒ 不是一次「登录尝试」,记账只会灌垃圾)。 + if !account.trim().is_empty() { + let (mark, msg) = if resp.0.code == 200 { + (1, "登录成功".to_string()) + } else { + (0, resp.0.msg.clone()) + }; + write_login_log(&state, &headers, account.trim(), mark, &msg).await; + } + resp +} + +/// 写一条登录日志(`base_sys_log`,`f_type = 1`)。 +/// +/// 🔴 **失败不冒泡**:日志写不进去绝不能让登录失败(官方同理, +/// 日志是旁路不是主链路)—— 只往服务端 stderr 打一行。 +/// 🔴 `f_login_mark`:1 成功 / 0 失败;`f_login_type`:0 登录 / 1 退出 +/// (退出日志本仓没有「登出」端点,恒写 0)。 +async fn write_login_log( + state: &AppState, + headers: &HeaderMap, + account: &str, + mark: i32, + msg: &str, +) { + // 账号 ⇒ 用户 id / 姓名(失败时用户可能不存在 ⇒ 只有账号)。 + let rows = state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_real_name, '') AS \"realName\" \ + FROM base_user WHERE f_account = $1::text LIMIT 1", + &[&account.to_string()], + ) + .await + .unwrap_or_default(); + let user_id = rows + .first() + .and_then(|r| r.get("id")) + .and_then(Value::as_str) + .unwrap_or("") + .to_string(); + let real_name = rows + .first() + .and_then(|r| r.get("realName")) + .and_then(Value::as_str) + .unwrap_or(""); + let user_name = if real_name.is_empty() { + account.to_string() + } else { + real_name.to_string() + }; + + let ip = client_ip(headers); + let ua = headers + .get(axum::http::header::USER_AGENT) + .and_then(|v| v.to_str().ok()) + .unwrap_or(""); + let (browser, platform) = parse_user_agent(ua); + + let id = crate::platform::ids::new_uuid(); + let mark_text = mark.to_string(); + let values: [Option; 11] = [ + Some(id), + Some(user_id.clone()), + Some(user_name), + Some("1".to_string()), + Some(ip), + Some(browser), + Some(platform), + Some(mark_text), + Some("0".to_string()), + Some(msg.to_string()), + Some(user_id), + ]; + // 参数一律按 text 绑定,类型转换交给 SQL 里的 `::integer`(与面 B 全仓同一口径)。 + let params: Vec<&(dyn ToSql + Sync)> = + values.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + if let Err(e) = state + .db + .exec_params( + "INSERT INTO base_sys_log (f_id, f_user_id, f_user_name, f_type, f_ip_address, \ + f_browser, f_plat_form, f_login_mark, f_login_type, f_description, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text, \ + $6::text, $7::text, $8::text::integer, $9::text::integer, $10::text, \ + $11::text, now(), 0, '0')", + ¶ms, + ) + .await + { + eprintln!("[auth] 写登录日志失败(不影响登录): {e}"); + } +} + +/// 客户端 IP —— 先看反代头(`X-Forwarded-For` 取第一个),再 `X-Real-IP`,最后回环地址。 +fn client_ip(headers: &HeaderMap) -> String { + for name in ["x-forwarded-for", "x-real-ip"] { + if let Some(value) = headers.get(name).and_then(|v| v.to_str().ok()) { + let first = value.split(',').next().unwrap_or("").trim(); + if !first.is_empty() { + return first.to_string(); + } + } + } + "127.0.0.1".to_string() +} + +/// 从 User-Agent 粗分「浏览器 / 操作系统」。 +/// +/// 🔴 只做**关键字分档**(官方用 `UserAgentUtil` 解析成同一组枚举)—— +/// 页面这两列只是给人看的,分不出就写「其他」,绝不返空串(空串看起来像数据丢了)。 +fn parse_user_agent(ua: &str) -> (String, String) { + let lower = ua.to_lowercase(); + let browser = if lower.contains("edg/") { + "Edge" + } else if lower.contains("chrome/") || lower.contains("crios/") { + "Chrome" + } else if lower.contains("firefox/") || lower.contains("fxios/") { + "Firefox" + } else if lower.contains("safari/") { + "Safari" + } else if lower.contains("msie") || lower.contains("trident") { + "IE" + } else { + "其他" + }; + let platform = if lower.contains("windows") { + "Windows" + } else if lower.contains("android") { + "Android" + } else if lower.contains("iphone") || lower.contains("ipad") || lower.contains("ios") { + "iOS" + } else if lower.contains("mac os") || lower.contains("macintosh") { + "macOS" + } else if lower.contains("linux") { + "Linux" + } else { + "其他" + }; + (browser.to_string(), platform.to_string()) } /// 当前用户(契约 §6.1)。 diff --git a/src/backend/src/platform/face_b.rs b/src/backend/src/platform/face_b.rs index 9bf1b2a..5bd0b17 100644 --- a/src/backend/src/platform/face_b.rs +++ b/src/backend/src/platform/face_b.rs @@ -2103,8 +2103,14 @@ pub async fn users_work_handover( /// /// 🔴 前端 `store/base.ts:48`:`this.dictionaryList = res.data.list` ⇒ `data` 必须是 /// **有 `list` 的对象**(裸数组会把整站的下拉选项打崩)。 -/// 本仓没有 `base_dictionary` / `base_dictionary_data` 表 ⇒ 恒返**空列表**, -/// 各页面的字典下拉退化为空(`getDictionaryData` 判空返 `[]`,不抛错)。 +/// 🔴 形状对齐官方 `DictionaryDataController.allBindDictionary`(`:121-170`): +/// 每项是 `{id, enCode, isTree, dictionaryList}` —— 注意**没有 `fullName`** +/// (官方就没给,前端也不需要)。 +/// 🔴 `isTree = 1` 的类型里 `dictionaryList` 是**树**(带 `children`), +/// `isTree = 0` 的是平铺数组 ⇒ 前端 `getDictionaryData(encode, id)` 两条分支都覆盖。 +/// +/// 这一条早先是「恒空列表」的占位(当时没有字典表);现在字典表与种子都有了, +/// 必须返真数据 —— 否则 `businessType` 之类全靠它喂的下拉永远是空的(而且不报错)。 pub async fn dictionary_data_all( State(state): State, headers: HeaderMap, @@ -2112,7 +2118,78 @@ pub async fn dictionary_data_all( if let Err(resp) = require_login_face_b(&state, &headers).await { return resp; } - ok(list_vo(Vec::new())) + let types = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_en_code, '') AS \"enCode\", \ + COALESCE(f_is_tree, 0) AS \"isTree\" \ + FROM base_dictionary_type WHERE COALESCE(f_delete_mark, 0) = 0 \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_full_name ASC", + &[], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "字典分类查询"), + }; + let data = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_parent_id, '0') AS \"parentId\", \ + COALESCE(f_full_name, '') AS \"fullName\", \ + COALESCE(f_en_code, '') AS \"enCode\", \ + f_dictionary_type_id AS \"dictionaryTypeId\" \ + FROM base_dictionary_data \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_enabled_mark, 1) = 1 \ + ORDER BY COALESCE(f_sort_code, 0) ASC", + + &[], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "字典数据查询"), + }; + let mut by_type: HashMap> = HashMap::new(); + for row in data { + let type_id = row + .get("dictionaryTypeId") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + by_type.entry(type_id).or_default().push(row); + } + let mut list: Vec = Vec::with_capacity(types.len()); + for mut type_row in types { + let type_id = type_row + .get("id") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + let is_tree = type_row.get("isTree").and_then(Value::as_i64).unwrap_or(0) == 1; + let rows = by_type.remove(&type_id).unwrap_or_default(); + let dictionary_list = if is_tree { + Value::Array(category_tree(rows)) + } else { + Value::Array( + rows.into_iter() + .map(|row| { + json!({ + "id": row.get("id").cloned().unwrap_or(Value::Null), + "fullName": row.get("fullName").cloned().unwrap_or(Value::Null), + "enCode": row.get("enCode").cloned().unwrap_or(Value::Null), + }) + }) + .collect(), + ) + }; + if let Some(obj) = type_row.as_object_mut() { + obj.insert("isTree".to_string(), json!(if is_tree { 1 } else { 0 })); + obj.insert("dictionaryList".to_string(), dictionary_list); + } + list.push(type_row); + } + ok(list_vo(list)) } /// `GET /api/system/HomeData` —— 控制台各卡片的数据源。 @@ -5236,25 +5313,25 @@ pub async fn self_subordinate( } } -/// `GET /api/permission/Users/Current/SystemLog` —— 登录日志。 +/// `GET /api/permission/Users/Current/SystemLog` —— **我的**登录日志。 /// -/// 🔴 本仓**没有**登录日志表(`base_log` 未建)⇒ 恒空分页,**形状必须对** -/// (`{pagination, list}`,前端 `res.data.list`)。 +/// 🔴 与 `GET /api/system/Log?category=1` 共用 [`log_page`](官方也是同一个 `LogService`), +/// 区别只有一个:这里**强制 `f_user_id = 当前用户`**(个人中心不该看到别人的登录记录)。 +/// 🔴 数据来源是 `base_sys_log`(登录成功/失败都落一行,见 `auth::write_login_log`) +/// —— 早先这里是恒空分页,页面形状对但永远没内容。 pub async fn self_system_log( State(state): State, headers: HeaderMap, raw: RawQuery, ) -> Json { - if let Err(resp) = require_login_face_b(&state, &headers).await { - return resp; + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + match log_page(&state, &raw, 1, Some(&user.user_id)).await { + Ok(data) => ok(data), + Err(resp) => resp, } - let paging = Paging::of(&raw); - ok(page_list( - paging.current_page, - paging.page_size, - 0, - Vec::new(), - )) } /// `GET /api/permission/Users/Current/getUserOrganizes` —— 我所属的组织(含祖先链)。 @@ -10341,6 +10418,1515 @@ pub async fn notice_reply_user_list( ok(list_vo(list)) } +// ================================================================ 系统日志(base_sys_log) +// +// 官方真源:`jnpf-exception/.../LogController.java`(`@RequestMapping("/api/system/Log")`)。 +// 吃它的是**五个页面**:`views/sysLog/{loginLog,operateLog,requestLog,errorLog}` + +// 个人中心「登录日志」(`_core/profile/components/SysLog.vue`,走 +// `permission/Users/Current/SystemLog`,与这里同一套数据)。 +// +// 🔴 **一张表装五种日志**,靠 `f_type` 区分:1 登录 / 2 访问 / 3 操作 / 4 异常 / 5 请求。 +// 官方 `switch(pagination.getCategory())` 只给 1 / 3 / 4 / 5 出数据, +// 其余(含 2)走 `default ⇒ fail(FA012 获取失败,数据不存在)` —— 照抄,不自己发挥。 +// 🔴 `creatorTime` 在官方 `LoginLogVO` / `HandleLogVO` 里是 **Long(毫秒)**, +// 不是日期串 ⇒ 必须按毫秒返回,否则四个页面的「时间」列全空。 + +/// 官方 `@SaCheckPermission({"sysLog.loginLog", "sysLog.requestLog", "sysLog.operateLog", +/// "sysLog.errorLog"}, mode = SaMode.OR)` 四选一;本仓 `guard()` 只吃一个 ⇒ +/// 取**登录日志**那个(页面默认 tab 就是登录日志,最贴近)。 +const EN_LOG: &str = "sysLog.loginLog"; + +/// `LoginLogVO` / `HandleLogVO` / `ErrorLogVO` / `RequestLogVO` 的**并集**原料 +/// (四个 VO 字段高度重叠,前端各取所需;多给不会错,少给就是空白列)。 +/// +/// 🔴 `abstracts` 是官方给登录日志单独补的(`loginLogVO.setAbstracts(entity.getDescription())`), +/// 本仓直接在同一条 SQL 里出,省一次内存遍历。 +const LOG_PROJECTION: &str = "f_id AS \"id\", f_user_id AS \"userId\", f_user_name AS \"userName\", \ + COALESCE(f_type, 0) AS \"type\", COALESCE(f_level, 0) AS \"levels\", \ + f_ip_address AS \"ipAddress\", f_ip_address_name AS \"ipAddressName\", \ + f_request_url AS \"requestUrl\", f_request_method AS \"requestMethod\", \ + COALESCE(f_request_duration, 0) AS \"requestDuration\", f_json AS \"jsons\", \ + f_plat_form AS \"platForm\", f_module_id AS \"moduleId\", f_module_name AS \"moduleName\", \ + f_browser AS \"browser\", f_request_param AS \"requestParam\", \ + f_request_target AS \"requestTarget\", f_description AS \"description\", \ + f_description AS \"abstracts\", \ + COALESCE(f_login_mark, 0) AS \"loginMark\", COALESCE(f_login_type, 0) AS \"loginType\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\""; + +/// 时间区间参数是否**像**时间戳(`YYYY-MM-DD…`)。 +/// +/// 🔴 不校验就直接塞进 `$n::text::timestamp` 的话,前端传个 `abc` 就是 PG 报错 ⇒ 500; +/// 这里「不像就当没传」,宁可少过滤也不要 500(与 `Paging` 的容错口径一致)。 +fn looks_like_time(s: &str) -> bool { + let bytes = s.as_bytes(); + bytes.len() >= 10 + && bytes.iter().take(10).enumerate().all(|(i, c)| { + if i == 4 || i == 7 { + *c == b'-' + } else { + c.is_ascii_digit() + } + }) +} + +/// 分页查日志 —— `/api/system/Log` 与 `Users/Current/SystemLog` **共用**这一条。 +/// +/// `only_user`:`Some(id)` ⇒ 只看这个人的(个人中心「登录日志」+ `/deleteLoginLog` 的口径)。 +async fn log_page( + state: &AppState, + raw: &RawQuery, + category: i64, + only_user: Option<&str>, +) -> Result> { + let paging = Paging::of(raw); + let mut conds = vec!["COALESCE(f_type, 0) = $1::text::integer".to_string()]; + // 🔴 `$1` 必须**真的用掉**(pglite 0.2.7:SQL 里留了 `$N` 不传参就 42P18)。 + let mut values: Vec> = vec![Some(category.to_string())]; + if let Some(uid) = only_user { + values.push(Some(uid.to_string())); + conds.push(format!("f_user_id = ${}::text", values.len())); + } + let keyword = crate::platform::sys::query_param(raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let n = values.len(); + conds.push(format!( + "(COALESCE(f_user_name, '') ILIKE ${n}::text \ + OR COALESCE(f_ip_address, '') ILIKE ${n}::text \ + OR COALESCE(f_request_url, '') ILIKE ${n}::text \ + OR COALESCE(f_module_name, '') ILIKE ${n}::text \ + OR COALESCE(f_description, '') ILIKE ${n}::text)" + )); + } + for (param, column, cast) in [ + ("loginMark", "COALESCE(f_login_mark, 0)", "::integer"), + ("loginType", "COALESCE(f_login_type, 0)", "::integer"), + ] { + let v = crate::platform::sys::query_param(raw, param) + .trim() + .to_string(); + if let Ok(n) = v.parse::() { + values.push(Some(n.to_string())); + conds.push(format!("{column} = ${}{cast}", values.len())); + } + } + let method = crate::platform::sys::query_param(raw, "requestMethod") + .trim() + .to_string(); + if !method.is_empty() { + values.push(Some(method)); + conds.push(format!("f_request_method = ${}::text", values.len())); + } + for (param, op) in [("startTime", ">="), ("endTime", "<=")] { + let v = crate::platform::sys::query_param(raw, param) + .trim() + .to_string(); + if looks_like_time(&v) { + values.push(Some(v)); + conds.push(format!( + "f_creator_time {op} ${}::text::timestamp", + values.len() + )); + } + } + let where_sql = conds.join(" AND "); + let count_sql = format!("SELECT COUNT(*)::text AS \"n\" FROM base_sys_log WHERE {where_sql}"); + let total: i64 = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows + .first() + .and_then(|r| r.get("n")) + .and_then(Value::as_str) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0), + Err(e) => return Err(db_error(e, "日志计数")), + }; + let mut list_values = values.clone(); + list_values.push(Some(paging.page_size.to_string())); + let limit_n = list_values.len(); + list_values.push(Some(paging.offset.to_string())); + let offset_n = list_values.len(); + let sql = format!( + "SELECT {LOG_PROJECTION} FROM base_sys_log WHERE {where_sql} \ + ORDER BY f_creator_time DESC NULLS LAST, f_id DESC \ + LIMIT ${limit_n}::text::integer OFFSET ${offset_n}::text::integer" + ); + let rows = match state + .db + .query_json_params(&sql, ¶ms_of(&list_values)) + .await + { + Ok(rows) => rows, + Err(e) => return Err(db_error(e, "日志列表查询")), + }; + Ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// `GET /api/system/Log?category=1|3|4|5` —— 分页列表(`PageListVO`)。 +pub async fn log_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_LOG).await { + return resp; + } + // 官方 `PaginationLogModel.category` 是 `int`(缺省 0 ⇒ 走 default 分支) + // ⇒ 本仓同样:不是 1/3/4/5 就原文案拒掉,别返回空列表假装成功。 + let category = crate::platform::sys::query_param(&raw, "category") + .trim() + .parse::() + .unwrap_or(0); + if !matches!(category, 1 | 3 | 4 | 5) { + return fail(code::FAIL, "获取失败,数据不存在"); + } + match log_page(&state, &raw, category, None).await { + Ok(data) => ok(data), + Err(resp) => resp, + } +} + +/// `GET /api/system/Log/{id}` —— 日志详情。 +pub async fn log_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_LOG).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!("SELECT {LOG_PROJECTION} FROM base_sys_log WHERE f_id = $1::text 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, "日志详情查询"), + } +} + +/// `DELETE /api/system/Log` —— 批量删除(body `{"ids": ["…"]}`)。 +/// +/// 🔴 官方 `LogDelForm.ids` 是 `String[]`,而本仓的 `crud` 工具把数组摊成逗号串 +/// ⇒ 两种都收(`string_to_array` 对单值也成立)。 +pub async fn log_delete( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_LOG).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let ids = match obj.get("ids") { + Some(Value::Array(items)) => items + .iter() + .filter_map(Value::as_str) + .map(str::trim) + .filter(|s| !s.is_empty()) + .collect::>() + .join(","), + Some(Value::String(s)) => s.trim().to_string(), + _ => String::new(), + }; + if ids.is_empty() { + return fail(code::FAIL, "删除失败,数据不存在"); + } + if let Err(e) = state + .db + .exec_params( + "DELETE FROM base_sys_log WHERE f_id = ANY(string_to_array($1::text, ','))", + &[&ids], + ) + .await + { + return db_error(e, "删除日志"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/Log/{type}` —— 按分类**一键清空**(全租户,不分人)。 +/// +/// 🔴 与官方一致:`type` 是**分类号**(1/3/4/5),**不是**日志 id —— +/// 所以这条路由不能实现成「删某一条」,否则管理员点「一键清空」会静默什么都不做。 +pub async fn log_clear( + State(state): State, + headers: HeaderMap, + Path(kind): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_LOG).await { + return resp; + } + let kind = kind.trim().to_string(); + let Ok(category) = kind.parse::() else { + return fail(code::FAIL, "获取失败,数据不存在"); + }; + let values = [Some(category.to_string())]; + if let Err(e) = state + .db + .exec_params( + "DELETE FROM base_sys_log WHERE COALESCE(f_type, 0) = $1::text::integer", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "清空日志"); + } + ok(Value::Null) +} + +/// `DELETE /api/system/Log/deleteLoginLog` —— 清空**自己**的登录日志。 +/// +/// 🔴 官方这一条带 `userOnline = 1`(`deleteHandleLog("1", 1, null)`)⇒ +/// **只删当前用户的**。与上一条「全租户清空」是两个不同语义,不能合并。 +pub async fn log_clear_login( + State(state): State, + headers: HeaderMap, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let values = [Some(user.user_id)]; + if let Err(e) = state + .db + .exec_params( + "DELETE FROM base_sys_log WHERE COALESCE(f_type, 0) = 1 AND f_user_id = $1::text", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "清空登录日志"); + } + ok(Value::Null) +} + +/// `GET /api/system/Log/ModuleName` —— 操作日志的「操作模块」下拉。 +/// +/// 官方返回**裸数组** `[{moduleName}]`(不是 `ListVO`)⇒ 前端 `map(o => o.moduleName)` 直接用。 +pub async fn log_module_name( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_LOG).await { + return resp; + } + let sql = "SELECT DISTINCT f_module_name AS \"moduleName\" FROM base_sys_log \ + WHERE COALESCE(f_module_name, '') <> '' ORDER BY f_module_name ASC"; + match state.db.query_json_params(sql, &[]).await { + Ok(rows) => ok(Value::Array(rows)), + Err(e) => db_error(e, "模块名查询"), + } +} + +// ================================================================ 审批常用语(base_common_words) +// +// 官方真源:`CommonWordsController.java`(`@RequestMapping("/api/system/CommonWords")`)。 +// 页面:`views/templateCenter/commonWords/{index,Form}.vue`。 +// +// 🔴 `f_common_words_type`:**0 公共 / 1 个人**。列表页固定 `searchInfo: {commonWordsType: 0}` +// ⇒ 这一页只看公共的;个人常用语是工作流意见框那侧在用(同一张表,靠 type 分)。 +// 🔴 `type = 1` 时官方**额外**加 `f_creator_user_id = 当前用户`,并按 `f_uses_num` 倒序 +// (「我常用」排前面)⇒ 这两个条件必须一起加,只加一个就把别人的个人常用语露出来。 + +/// 🔴 官方 `CommonWordsController` **一个 `@SaCheckPermission` 都没有** —— +/// 常用语是「登录即可用」的功能(工作流意见框里随手点)⇒ 本仓**故意不挂 `guard()`**, +/// 只做 `require_login_face_b`。别顺手加个权限码,那会让普通员工打不开意见框的常用语。 +const COMMON_WORDS_PROJECTION: &str = "f_id AS \"id\", f_system_ids AS \"systemIds\", \ + f_common_words_text AS \"commonWordsText\", \ + COALESCE(f_common_words_type, 0) AS \"commonWordsType\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", COALESCE(f_enabled_mark, 1) AS \"enabledMark\", \ + COALESCE(f_uses_num, 0) AS \"usesNum\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\""; + +const COMMON_WORDS_WRITE_FIELDS: [(&str, &str, &str); 5] = [ + ("systemIds", "f_system_ids", ""), + ("commonWordsText", "f_common_words_text", ""), + ("commonWordsType", "f_common_words_type", "::integer"), + ("sortCode", "f_sort_code", "::bigint"), + ("enabledMark", "f_enabled_mark", "::integer"), +]; + +/// `GET /api/system/CommonWords` —— 分页列表(`PageListVO`)。 +pub async fn common_words_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let paging = Paging::of(&raw); + let mut conds = vec!["COALESCE(f_delete_mark, 0) = 0".to_string()]; + let mut values: Vec> = Vec::new(); + let kind = crate::platform::sys::query_param(&raw, "commonWordsType") + .trim() + .parse::() + .ok(); + if let Some(kind) = kind { + values.push(Some(kind.to_string())); + conds.push(format!( + "COALESCE(f_common_words_type, 0) = ${}::text::integer", + values.len() + )); + if kind == 1 { + values.push(Some(user.user_id.clone())); + conds.push(format!("f_creator_user_id = ${}::text", values.len())); + } + } + let enabled = crate::platform::sys::query_param(&raw, "enabledMark") + .trim() + .parse::() + .ok(); + if let Some(enabled) = enabled { + values.push(Some(enabled.to_string())); + conds.push(format!( + "COALESCE(f_enabled_mark, 1) = ${}::text::integer", + values.len() + )); + } + let keyword = crate::platform::sys::query_param(&raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + conds.push(format!( + "COALESCE(f_common_words_text, '') ILIKE ${}::text", + values.len() + )); + } + let where_sql = conds.join(" AND "); + let count_sql = format!( + "SELECT COUNT(*)::text AS \"n\" FROM base_common_words WHERE {where_sql}" + ); + let total: i64 = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows + .first() + .and_then(|r| r.get("n")) + .and_then(Value::as_str) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0), + Err(e) => return db_error(e, "常用语计数"), + }; + let mut list_values = values.clone(); + list_values.push(Some(paging.page_size.to_string())); + let limit_n = list_values.len(); + list_values.push(Some(paging.offset.to_string())); + let offset_n = list_values.len(); + // 🔴 排序与官方一致:个人常用语先按使用次数倒序(「最常用」在前),再按 sortCode。 + let order = if kind == Some(1) { + "COALESCE(f_uses_num, 0) DESC, COALESCE(f_sort_code, 0) ASC, f_creator_time DESC NULLS LAST" + } else { + "COALESCE(f_sort_code, 0) ASC, f_creator_time DESC NULLS LAST" + }; + let sql = format!( + "SELECT {COMMON_WORDS_PROJECTION} FROM base_common_words WHERE {where_sql} \ + ORDER BY {order} LIMIT ${limit_n}::text::integer OFFSET ${offset_n}::text::integer" + ); + match state + .db + .query_json_params(&sql, ¶ms_of(&list_values)) + .await + { + Ok(rows) => ok(page_list(paging.current_page, paging.page_size, total, rows)), + Err(e) => db_error(e, "常用语列表查询"), + } +} + +/// `GET /api/system/CommonWords/Selector?type=` —— 下拉(`ListVO`)。 +pub async fn common_words_selector( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let kind = crate::platform::sys::query_param(&raw, "type") + .trim() + .parse::() + .ok(); + let (sql, values) = match kind { + Some(1) => ( + format!( + "SELECT {COMMON_WORDS_PROJECTION} FROM base_common_words \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_enabled_mark, 1) = 1 \ + AND COALESCE(f_common_words_type, 0) = 1 AND f_creator_user_id = $1::text \ + ORDER BY COALESCE(f_uses_num, 0) DESC, COALESCE(f_sort_code, 0) ASC" + ), + vec![Some(user.user_id)], + ), + Some(kind) => ( + format!( + "SELECT {COMMON_WORDS_PROJECTION} FROM base_common_words \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_enabled_mark, 1) = 1 \ + AND COALESCE(f_common_words_type, 0) = $1::text::integer \ + ORDER BY COALESCE(f_sort_code, 0) ASC" + ), + vec![Some(kind.to_string())], + ), + None => ( + format!( + "SELECT {COMMON_WORDS_PROJECTION} FROM base_common_words \ + WHERE COALESCE(f_delete_mark, 0) = 0 AND COALESCE(f_enabled_mark, 1) = 1 \ + ORDER BY COALESCE(f_sort_code, 0) ASC" + ), + Vec::new(), + ), + }; + match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => ok(list_vo(rows)), + Err(e) => db_error(e, "常用语下拉查询"), + } +} + +/// `GET /api/system/CommonWords/{id}` —— 详情。 +pub async fn common_words_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {COMMON_WORDS_PROJECTION} FROM base_common_words \ + 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(mut row) => { + // 官方 `getInfo` 会补 `systemNames`(表单里只读展示);没有就空串, + // 让前端 `res.data.systemNames || []` 的兜底走空分支。 + if let Some(obj) = row.as_object_mut() { + obj.insert("systemNames".to_string(), Value::String(String::new())); + } + ok(row) + } + None => fail(code::FAIL, "数据不存在"), + }, + Err(e) => db_error(e, "常用语详情查询"), + } +} + +/// `POST /api/system/CommonWords` —— 新建(同 `text + type` 判重 ⇒ `SYS105`)。 +pub async fn common_words_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).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 text = obj + .get("commonWordsText") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if text.is_empty() { + return fail(code::FAIL, "常用语不能为空"); + } + let kind = obj + .get("commonWordsType") + .and_then(Value::as_i64) + .unwrap_or(0); + if let Err(resp) = ensure_common_words_unique(&state, &text, kind, None).await { + return resp; + } + let new_id = new_uuid(); + let mut columns: Vec<&str> = vec!["f_id", "f_tenant_id", "f_common_words_text"]; + let mut casts: Vec<&str> = vec!["", "", ""]; + let mut values: Vec> = vec![Some(new_id), Some("0".to_string()), Some(text)]; + for (json_key, column, cast) in COMMON_WORDS_WRITE_FIELDS { + if column == "f_common_words_text" || !obj.contains_key(json_key) { + continue; + } + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + // 缺省值只在 body **没给**时才补(body 给了 `enabledMark: 0` 就必须存 0)。 + for (json_key, column, cast, default) in [ + ("commonWordsType", "f_common_words_type", "::integer", kind.to_string()), + ("enabledMark", "f_enabled_mark", "::integer", "1".to_string()), + ("sortCode", "f_sort_code", "::bigint", "0".to_string()), + ] { + if obj.contains_key(json_key) { + continue; + } + columns.push(column); + casts.push(cast); + values.push(Some(default)); + } + // `f_uses_num` 不在写字段里(只有 `UsesNum` 端点会动它)⇒ 新建恒 0。 + columns.push("f_uses_num"); + casts.push("::bigint"); + values.push(Some("0".to_string())); + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.user_id)); + 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_common_words ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建常用语"); + } + ok(Value::Null) +} + +/// 常用语判重:`f_common_words_text + f_common_words_type` 同档内唯一(`SYS105`)。 +async fn ensure_common_words_unique( + state: &AppState, + text: &str, + kind: i64, + exclude_id: Option<&str>, +) -> Result<(), Json> { + let exclude = exclude_id.map(str::to_string); + let kind_text = kind.to_string(); + match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_common_words \ + WHERE f_common_words_text = $1::text \ + AND COALESCE(f_common_words_type, 0) = $2::text::integer \ + AND COALESCE(f_delete_mark, 0) = 0 \ + AND ($3::text IS NULL OR f_id <> $3::text) LIMIT 1", + &[&text.to_string(), &kind_text, &exclude], + ) + .await + { + Ok(rows) if rows.is_empty() => Ok(()), + Ok(_) => Err(fail(code::FAIL, "常用语已存在")), + Err(e) => { + eprintln!("[face-b] 常用语判重失败: {e}"); + Err(fail(code::EXCEPTION, "系统异常,请联系管理员")) + } + } +} + +/// `PUT /api/system/CommonWords/{id}` —— 改(只 SET body 出现的键)。 +pub async fn common_words_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + 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 text = obj + .get("commonWordsText") + .and_then(Value::as_str) + .map(|s| s.trim().to_string()) + .unwrap_or_default(); + if text.is_empty() { + return fail(code::FAIL, "常用语不能为空"); + } + let kind = obj + .get("commonWordsType") + .and_then(Value::as_i64) + .unwrap_or(0); + if let Err(resp) = ensure_common_words_unique(&state, &text, kind, Some(&id)).await { + return resp; + } + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in COMMON_WORDS_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); + } + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_common_words 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/system/CommonWords/{id}` —— 删(软删)。 +pub async fn common_words_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let values = [Some(id.trim().to_string())]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_common_words SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1::text", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "删除常用语"); + } + ok(Value::Null) +} + +/// `POST /api/system/CommonWords/UsesNum` —— 记一次使用(`f_uses_num + 1`)。 +/// +/// 🔴 官方按**文本**累加(`addCommonWordsNum(commonWordsText)`),不是按 id +/// ⇒ 个人常用语(同文本多行)会被一起加。照抄,别自作聪明改成按 id。 +pub async fn common_words_uses_num( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let text = obj + .get("commonWordsText") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if text.is_empty() { + return fail(code::FAIL, "常用语不能为空"); + } + if let Err(e) = state + .db + .exec_params( + "UPDATE base_common_words SET f_uses_num = COALESCE(f_uses_num, 0) + 1 \ + WHERE f_common_words_text = $1::text AND COALESCE(f_delete_mark, 0) = 0", + &[&text], + ) + .await + { + return db_error(e, "常用语使用计数"); + } + ok(Value::Null) +} + +// ================================================================ 单据规则(base_bill_rule) +// +// 官方真源:`BillRuleController.java` + `BillRuleMapper.java::getNumber`。 +// 页面:`views/templateCenter/billRule/{index,Form}.vue`(列表/表单), +// `BillNumber/{enCode}` 则由**任何要单号的表单**调用。 +// +// 🔴 生成器是**有状态的**:`f_this_number` + `f_output_number` 每次发号都回写, +// 所以「删规则」被官方加了闸(`f_output_number` 非空 ⇒ `SYS003 单据已经被使用`)。 +// 🔴 三种方式(`f_type`):1 时间格式 / 2 随机数 / 3 UUID。时间格式那支还要 +// 「**跨天归零**」——从上一号的日期段里把日期抠出来跟今天比,不同就从 0 重来。 + +/// 官方 `@SaCheckPermission("templateCenter.billRule")`。 +const EN_BILL_RULE: &str = "templateCenter.billRule"; + +const BILL_RULE_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", f_prefix AS \"prefix\", f_suffix AS \"suffix\", \ + f_date_format AS \"dateFormat\", COALESCE(f_digit, 0) AS \"digit\", \ + f_start_number AS \"startNumber\", f_example AS \"example\", \ + COALESCE(f_this_number, 0) AS \"thisNumber\", f_output_number AS \"outputNumber\", \ + f_description AS \"description\", COALESCE(f_enabled_mark, 0) AS \"enabledMark\", \ + f_category AS \"category\", COALESCE(f_sort_code, 0) AS \"sortCode\", \ + COALESCE(f_type, 1) AS \"type\", COALESCE(f_random_digit, 0) AS \"randomDigit\", \ + COALESCE(f_random_type, 1) AS \"randomType\", f_creator_user_id AS \"creatorUserId\", \ + (EXTRACT(EPOCH FROM f_creator_time) * 1000)::bigint AS \"creatorTime\", \ + (EXTRACT(EPOCH FROM f_last_modify_time) * 1000)::bigint AS \"lastModifyTime\""; + +/// `BillRuleCrForm` / `BillRuleUpForm` ⇒ 列。 +/// +/// 🔴 **不含 `thisNumber` / `outputNumber`**:那是生成器状态,只能由 `BillNumber` 写 +/// (表单改了它俩就等于篡改流水号);官方 update 也是自己决定「清空 or 保留」。 +const BILL_RULE_WRITE_FIELDS: [(&str, &str, &str); 14] = [ + ("fullName", "f_full_name", ""), + ("enCode", "f_en_code", ""), + ("prefix", "f_prefix", ""), + ("suffix", "f_suffix", ""), + ("dateFormat", "f_date_format", ""), + ("digit", "f_digit", "::integer"), + ("startNumber", "f_start_number", ""), + ("example", "f_example", ""), + ("description", "f_description", ""), + ("enabledMark", "f_enabled_mark", "::integer"), + ("category", "f_category", ""), + ("sortCode", "f_sort_code", "::bigint"), + ("type", "f_type", "::integer"), + ("randomDigit", "f_random_digit", "::integer"), +]; + +/// 批量取字典数据名(`base_dictionary_data.f_full_name`)。 +/// +/// 单据规则的 `f_category` 存的是**字典数据 id**(`businessType` 那一组), +/// 列表要显示中文名 ⇒ 一次查回来拼。 +async fn dict_names(state: &AppState, ids: &[String]) -> HashMap { + let mut unique: Vec = ids.iter().filter(|s| !s.is_empty()).cloned().collect(); + unique.sort(); + unique.dedup(); + if unique.is_empty() { + return HashMap::new(); + } + let joined = unique.join(","); + match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"name\" FROM base_dictionary_data \ + WHERE f_id = ANY(string_to_array($1::text, ','))", + &[&joined], + ) + .await + { + Ok(rows) => rows + .into_iter() + .filter_map(|row| { + let id = row.get("id").and_then(Value::as_str)?.to_string(); + let name = row.get("name").and_then(Value::as_str)?.to_string(); + Some((id, name)) + }) + .collect(), + Err(e) => { + eprintln!("[face-b] 字典名查询失败(降级为空): {e}"); + HashMap::new() + } + } +} + +/// 给单据规则行补 `category`(中文名)与 `creatorUser`(`姓名/账号`)。 +fn shape_bill_rule_row(row: &mut Value, dict: &HashMap, labels: &HashMap) { + let Some(obj) = row.as_object_mut() else { + return; + }; + let category_id = obj + .get("category") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + if let Some(name) = dict.get(&category_id) { + obj.insert("category".to_string(), Value::String(name.clone())); + // 官方 `BillRuleListVO` 把 `category` 覆盖成名字(原 id 不留), + // 但表单回填需要 id —— `getInfo` 走的是另一条路径(原样返回 id)。 + } + let creator = obj + .get("creatorUserId") + .and_then(Value::as_str) + .unwrap_or_default() + .to_string(); + let label = labels.get(&creator).cloned().unwrap_or_default(); + obj.insert("creatorUser".to_string(), Value::String(label)); + obj.remove("creatorUserId"); +} + +/// 分页查单据规则 —— 列表与 `Selector` 共用。 +async fn bill_rule_page( + state: &AppState, + raw: &RawQuery, + only_enabled: bool, +) -> Result> { + let paging = Paging::of(raw); + let mut conds = vec!["COALESCE(f_delete_mark, 0) = 0".to_string()]; + let mut values: Vec> = Vec::new(); + if only_enabled { + conds.push("COALESCE(f_enabled_mark, 0) = 1".to_string()); + } + let keyword = crate::platform::sys::query_param(raw, "keyword") + .trim() + .to_string(); + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let n = values.len(); + conds.push(format!( + "(COALESCE(f_full_name, '') ILIKE ${n}::text OR COALESCE(f_en_code, '') ILIKE ${n}::text)" + )); + } + // 🔴 列表页传 `categoryId`,`Selector` 传 `categoryId`(同一个字段,官方两处都读它)。 + let category = crate::platform::sys::query_param(raw, "categoryId") + .trim() + .to_string(); + if !category.is_empty() { + values.push(Some(category)); + conds.push(format!("f_category = ${}::text", values.len())); + } + let enabled = crate::platform::sys::query_param(raw, "enabledMark") + .trim() + .parse::() + .ok(); + if let Some(enabled) = enabled { + values.push(Some(enabled.to_string())); + conds.push(format!( + "COALESCE(f_enabled_mark, 0) = ${}::text::integer", + values.len() + )); + } + let where_sql = conds.join(" AND "); + let count_sql = format!("SELECT COUNT(*)::text AS \"n\" FROM base_bill_rule WHERE {where_sql}"); + let total: i64 = match state.db.query_json_params(&count_sql, ¶ms_of(&values)).await { + Ok(rows) => rows + .first() + .and_then(|r| r.get("n")) + .and_then(Value::as_str) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0), + Err(e) => return Err(db_error(e, "单据规则计数")), + }; + let mut list_values = values.clone(); + list_values.push(Some(paging.page_size.to_string())); + let limit_n = list_values.len(); + list_values.push(Some(paging.offset.to_string())); + let offset_n = list_values.len(); + let sql = format!( + "SELECT {BILL_RULE_PROJECTION} FROM base_bill_rule WHERE {where_sql} \ + ORDER BY COALESCE(f_sort_code, 0) ASC, f_creator_time DESC NULLS LAST \ + LIMIT ${limit_n}::text::integer OFFSET ${offset_n}::text::integer" + ); + let rows = match state + .db + .query_json_params(&sql, ¶ms_of(&list_values)) + .await + { + Ok(rows) => rows, + Err(e) => return Err(db_error(e, "单据规则列表查询")), + }; + let category_ids: Vec = rows + .iter() + .filter_map(|r| r.get("category").and_then(Value::as_str).map(str::to_string)) + .collect(); + let creator_ids: Vec = rows + .iter() + .filter_map(|r| r.get("creatorUserId").and_then(Value::as_str).map(str::to_string)) + .collect(); + let dict = dict_names(state, &category_ids).await; + let labels = user_labels(state, &creator_ids).await; + let list: Vec = rows + .into_iter() + .map(|mut row| { + shape_bill_rule_row(&mut row, &dict, &labels); + row + }) + .collect(); + Ok(page_list(paging.current_page, paging.page_size, total, list)) +} + +/// `GET /api/system/BillRule` —— 分页列表(`PageListVO`)。 +pub async fn bill_rule_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + match bill_rule_page(&state, &raw, false).await { + Ok(data) => ok(data), + Err(resp) => resp, + } +} + +/// `GET /api/system/BillRule/Selector` —— 下拉(只给启用的;**也是 `PageListVO`**)。 +/// +/// 🔴 官方这个端点返回的是 `PageListVO`(带 `pagination`),不是 `ListVO` +/// —— 前端 `getBillRuleSelector` 直接用 `res.data.list`,两种都能吃, +/// 但保持一致才不会被下一处「按官方 VO 校对」的检查判红。 +pub async fn bill_rule_selector( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + match bill_rule_page(&state, &raw, true).await { + Ok(data) => ok(data), + Err(resp) => resp, + } +} + +/// `GET /api/system/BillRule/{id}` —— 详情(`category` 原样返**id**,表单回填要用)。 +pub async fn bill_rule_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + let id = id.trim().to_string(); + let sql = format!( + "SELECT {BILL_RULE_PROJECTION} FROM base_bill_rule \ + 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, "单据规则详情查询"), + } +} + +/// 单据规则判重:`fullName` 与 `enCode` 各自唯一(`EXIST001` / `EXIST002`)。 +async fn ensure_bill_rule_unique( + state: &AppState, + full_name: Option<&str>, + en_code: Option<&str>, + exclude_id: Option<&str>, +) -> Result<(), Json> { + let exclude = exclude_id.map(str::to_string); + for (value, column, msg) in [ + (full_name, "f_full_name", "名称不能重复"), + (en_code, "f_en_code", "编码不能重复"), + ] { + let Some(value) = value.filter(|v| !v.trim().is_empty()) else { + continue; + }; + let sql = format!( + "SELECT f_id AS \"id\" FROM base_bill_rule WHERE {column} = $1::text \ + AND COALESCE(f_delete_mark, 0) = 0 \ + AND ($2::text IS NULL OR f_id <> $2::text) LIMIT 1" + ); + match state + .db + .query_json_params(&sql, &[&value.to_string(), &exclude]) + .await + { + Ok(rows) if rows.is_empty() => {} + Ok(_) => return Err(fail(code::FAIL, msg)), + Err(e) => { + eprintln!("[face-b] 单据规则判重失败: {e}"); + return Err(fail(code::EXCEPTION, "系统异常,请联系管理员")); + } + } + } + Ok(()) +} + +/// `POST /api/system/BillRule` —— 新建。 +pub async fn bill_rule_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match guard(&state, &headers, EN_BILL_RULE).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(); + let en_code = obj + .get("enCode") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + if full_name.is_empty() || en_code.is_empty() { + return fail(code::FAIL, "名称或编码不能为空"); + } + if let Err(resp) = + ensure_bill_rule_unique(&state, Some(&full_name), Some(&en_code), None).await + { + return resp; + } + 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), + Some("0".to_string()), + Some(full_name), + Some(en_code), + ]; + for (json_key, column, cast) in BILL_RULE_WRITE_FIELDS { + if column == "f_full_name" || column == "f_en_code" || !obj.contains_key(json_key) { + continue; + } + columns.push(column); + casts.push(cast); + values.push(value_to_text(obj.get(json_key))); + } + // 缺省值只在**这一列还没加过**时补(`type` 既在写字段里、又要有默认值 ⇒ + // 直接无条件 push 会让 SQL 里出现两个 `f_type`,PG 报 42701)。 + for (column, cast, default) in [ + ("f_enabled_mark", "::integer", "1".to_string()), + ("f_sort_code", "::bigint", "0".to_string()), + ("f_type", "::integer", "1".to_string()), + ] { + if columns.contains(&column) { + continue; + } + columns.push(column); + casts.push(cast); + values.push(Some(default)); + } + columns.push("f_creator_user_id"); + casts.push(""); + values.push(Some(user.user_id)); + 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_bill_rule ({}) VALUES ({})", + columns.join(", "), + marks.join(", ") + ); + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "新建单据规则"); + } + ok(Value::Null) +} + +/// `PUT /api/system/BillRule/{id}` —— 修改。 +/// +/// 🔴 **生成规则变了就清空流水号**(官方那段四条件判断):前缀/后缀**长度**变、 +/// 位数变、日期格式变 ⇒ `thisNumber` / `outputNumber` 归 NULL,否则沿用。 +/// 照抄这段才是对的:只按「字段是否出现」判会把「改个描述」也当成规则变更。 +pub async fn bill_rule_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + 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, + }; + if let Err(resp) = ensure_bill_rule_unique( + &state, + obj.get("fullName").and_then(Value::as_str), + obj.get("enCode").and_then(Value::as_str), + Some(&id), + ) + .await + { + return resp; + } + // 读旧行(判「规则是否变了」必须有旧值)。 + let old = match state + .db + .query_json_params( + "SELECT f_prefix AS \"prefix\", f_suffix AS \"suffix\", \ + COALESCE(f_digit, 0) AS \"digit\", COALESCE(f_type, 1) AS \"type\", \ + f_date_format AS \"dateFormat\" \ + FROM base_bill_rule WHERE f_id = $1::text AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows.into_iter().next(), + Err(e) => return db_error(e, "读单据规则"), + }; + let Some(old) = old else { + return fail(code::FAIL, "更新失败,数据不存在"); + }; + let text_of = |v: Option<&Value>| v.and_then(Value::as_str).unwrap_or("").to_string(); + let new_prefix = if obj.contains_key("prefix") { + text_of(obj.get("prefix")) + } else { + text_of(old.get("prefix")) + }; + let new_suffix = if obj.contains_key("suffix") { + text_of(obj.get("suffix")) + } else { + text_of(old.get("suffix")) + }; + let new_digit = obj + .get("digit") + .and_then(Value::as_i64) + .unwrap_or_else(|| old.get("digit").and_then(Value::as_i64).unwrap_or(0)); + let new_format = if obj.contains_key("dateFormat") { + text_of(obj.get("dateFormat")) + } else { + text_of(old.get("dateFormat")) + }; + let old_prefix = text_of(old.get("prefix")); + let old_suffix = text_of(old.get("suffix")); + let old_digit = old.get("digit").and_then(Value::as_i64).unwrap_or(0); + let old_format = text_of(old.get("dateFormat")); + let rule_changed = (old_prefix.chars().count() != new_prefix.chars().count() + && !old_prefix.is_empty() + && !new_prefix.is_empty()) + || (old_suffix.chars().count() != new_suffix.chars().count() + && !old_suffix.is_empty() + && !new_suffix.is_empty()) + || old_digit != new_digit + || old_format != new_format; + + let mut sets: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + for (json_key, column, cast) in BILL_RULE_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 rule_changed { + sets.push("f_this_number = NULL".to_string()); + sets.push("f_output_number = NULL".to_string()); + } + sets.push("f_last_modify_time = now()".to_string()); + values.push(Some(id)); + let sql = format!( + "UPDATE base_bill_rule 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) +} + +/// `PUT /api/system/BillRule/{id}/Actions/State` —— 启用/禁用来回切。 +pub async fn bill_rule_state( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + let id = id.trim().to_string(); + match state + .db + .exec_params( + "UPDATE base_bill_rule \ + SET f_enabled_mark = CASE WHEN COALESCE(f_enabled_mark, 0) = 1 THEN 0 ELSE 1 END, \ + f_last_modify_time = now() \ + WHERE f_id = $1::text", + &[&id], + ) + .await + { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "切换单据规则状态"), + } +} + +/// `DELETE /api/system/BillRule/{id}` —— 删(软删)。 +/// +/// 🔴 **已发过号的规则不许删**(官方 `SYS003 单据已经被使用,不允许被删除`): +/// `f_output_number` 非空说明这个编码已经在业务数据里出现过,删了就对不上。 +pub async fn bill_rule_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + let user = match guard(&state, &headers, EN_BILL_RULE).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let id = id.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT f_output_number AS \"outputNumber\" FROM base_bill_rule \ + 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 output = row + .get("outputNumber") + .and_then(Value::as_str) + .unwrap_or_default(); + if !output.is_empty() { + return fail(code::FAIL, "单据已经被使用,不允许被删除"); + } + let values = [Some(user.user_id), Some(id)]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_bill_rule SET f_delete_mark = 1, f_delete_time = now(), \ + f_delete_user_id = $1::text WHERE f_id = $2::text", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "删除单据规则"); + } + ok(Value::Null) +} + +/// `f_date_format`(官方那套大写占位符)⇒ PG `to_char` 的模板。 +/// +/// 🔴 只差两处:`HH` 在 PG 里是 **12 小时制**(要 `HH24`)、`SSS` 在 PG 里叫 `MS` +/// ⇒ 直接拿 `YYYYMMDDHH` 去 `to_char` 会得到「下午 03 点」那种错号。 +/// 🔴 `no` / 空 ⇒ `None`(官方 `dateForValue = "no"` 时**不拼日期段**)。 +fn to_char_pattern(date_format: &str) -> Option<&'static str> { + match date_format.trim() { + "YYYY" => Some("YYYY"), + "YYYYMM" => Some("YYYYMM"), + "YYYYMMDD" => Some("YYYYMMDD"), + "YYYYMMDDHH" => Some("YYYYMMDDHH24"), + "YYYYMMDDHHmm" => Some("YYYYMMDDHH24MI"), + "YYYYMMDDHHmmss" => Some("YYYYMMDDHH24MISS"), + "YYYYMMDDHHmmssSSS" => Some("YYYYMMDDHH24MISSMS"), + _ => None, + } +} + +/// `GET /api/system/BillRule/BillNumber/{enCode}` —— **发一个流水号**(会写库)。 +/// +/// 分支与官方 `BillRuleMapper.getNumber` 一一对应: +/// 1. `f_type = 2` 随机数:`f_random_type = 1` ⇒ 数字,否则大写字母; +/// 2. `f_type = 3` UUID(大写、带连字符 —— 官方 `IdUtil.randomUUID().toUpperCase()`); +/// 3. 其余按时间格式:`前缀 + 日期段 + 补零流水 + 后缀`,并做**跨天归零**。 +pub async fn bill_rule_number( + State(state): State, + headers: HeaderMap, + Path(en_code): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let en_code = en_code.trim().to_string(); + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", COALESCE(f_type, 1) AS \"type\", \ + COALESCE(f_prefix, '') AS \"prefix\", COALESCE(f_suffix, '') AS \"suffix\", \ + COALESCE(f_digit, 0) AS \"digit\", COALESCE(f_start_number, '') AS \"startNumber\", \ + COALESCE(f_this_number, 0) AS \"thisNumber\", \ + COALESCE(f_output_number, '') AS \"outputNumber\", \ + COALESCE(f_date_format, '') AS \"dateFormat\", \ + COALESCE(f_random_digit, 0) AS \"randomDigit\", \ + COALESCE(f_random_type, 1) AS \"randomType\" \ + FROM base_bill_rule WHERE f_en_code = $1::text \ + AND COALESCE(f_delete_mark, 0) = 0 LIMIT 1", + &[&en_code], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "读单据规则"), + }; + let Some(row) = rows.into_iter().next() else { + return fail(code::FAIL, "单据规则不存在"); + }; + let id = row.get("id").and_then(Value::as_str).unwrap_or("").to_string(); + let kind = row.get("type").and_then(Value::as_i64).unwrap_or(1); + let prefix = row.get("prefix").and_then(Value::as_str).unwrap_or(""); + let suffix = row.get("suffix").and_then(Value::as_str).unwrap_or(""); + let digit = row.get("digit").and_then(Value::as_i64).unwrap_or(0).max(0); + let start_number = row + .get("startNumber") + .and_then(Value::as_str) + .unwrap_or("") + .trim() + .parse::() + .unwrap_or(0); + let output = row.get("outputNumber").and_then(Value::as_str).unwrap_or(""); + + let mut number = String::from(prefix); + let mut new_this = 0_i64; + if kind == 2 { + let width = row.get("randomDigit").and_then(Value::as_i64).unwrap_or(16); + let digits_only = row.get("randomType").and_then(Value::as_i64).unwrap_or(1) == 1; + number.push_str(&random_chunk(width, digits_only)); + } else if kind == 3 { + number.push_str(&new_uuid().to_uppercase()); + } else { + let format = row.get("dateFormat").and_then(Value::as_str).unwrap_or(""); + let pattern = to_char_pattern(format); + let date_part = match pattern { + Some(p) => match state + .db + .query_json_params("SELECT to_char(now(), $1::text) AS \"d\"", &[&p.to_string()]) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r.get("d")) + .and_then(Value::as_str) + .unwrap_or("") + .to_string(), + Err(e) => return db_error(e, "取当前日期段"), + }, + None => String::new(), + }; + // 跨天归零:官方是从上一号的**日期段**里抠出来比(不是比 lastModifyTime)。 + let prev_this = row.get("thisNumber").and_then(Value::as_i64).unwrap_or(0); + let suffix_len = suffix.chars().count() as i64; + let date_len = date_part.chars().count() as i64; + let prev_out_len = output.chars().count() as i64; + let same_day = if output.is_empty() || date_len == 0 { + output.is_empty() + } else { + let start = prev_out_len - date_len - digit - suffix_len; + let end = prev_out_len - digit - suffix_len; + if start < 0 || end < start { + false + } else { + let prev_date: String = output + .chars() + .skip(start as usize) + .take((end - start) as usize) + .collect(); + prev_date == date_part + } + }; + new_this = if output.is_empty() { + 0 + } else if same_day { + prev_this + 1 + } else { + 0 + }; + number.push_str(&date_part); + let serial = start_number + new_this; + let width = digit as usize; + let padded = if width > 0 { + format!("{:0>width$}", serial, width = width) + } else { + serial.to_string() + }; + number.push_str(&padded); + } + number.push_str(suffix); + + // 只有时间格式那支才有「流水号状态」要回写;随机数/UUID 不动 `f_this_number`。 + if kind != 2 && kind != 3 { + let values = [ + Some(new_this.to_string()), + Some(number.clone()), + Some(id), + ]; + if let Err(e) = state + .db + .exec_params( + "UPDATE base_bill_rule SET f_this_number = $1::text::integer, \ + f_output_number = $2::text, f_last_modify_time = now() \ + WHERE f_id = $3::text", + ¶ms_of(&values), + ) + .await + { + return db_error(e, "回写流水号"); + } + } + ok(Value::String(number)) +} + +/// 官方 `RandomUtil.randomNumbers(digit)` / `randomStringUpper(digit)` 的本地替代。 +/// +/// 不引第三方随机库:用 uuid 的字节当种子做 xorshift —— 每次调用都重新取种子, +/// 所以连续调用不会退化成同一个串。 +fn random_chunk(width: i64, digits_only: bool) -> String { + let width = width.clamp(0, 64) as usize; + let mut seed: u64 = 0xcbf2_9ce4_8422_2325; + for byte in new_uuid().bytes() { + seed ^= u64::from(byte); + seed = seed.wrapping_mul(0x0000_0100_0000_01b3); + } + let mut out = String::with_capacity(width); + for _ in 0..width { + seed ^= seed << 13; + seed ^= seed >> 7; + seed ^= seed << 17; + let (base, span) = if digits_only { + (b'0', 10_u64) + } else { + (b'A', 26_u64) + }; + out.push((base + (seed % span) as u8) as char); + } + out +} + +/// `GET /api/system/BillRule/{id}/Actions/Export` —— **本仓不支持**。 +/// +/// 官方走 `DataFileExport`(往文件服务写一个 `.bb` 再返 `DownloadVO.url`); +/// 本仓没有文件服务 ⇒ 明确失败 + 人话,**不假装成功**(假装成功会让前端 +/// `downloadByUrl(undefined)` 静默什么都不做,比报错更难查)。 +pub async fn bill_rule_export( + State(state): State, + headers: HeaderMap, + Path(_id): Path, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + fail(code::FAIL, "本仓未配置文件服务,暂不支持导出") +} + +/// `POST /api/system/BillRule/Actions/Import` —— 同上,**本仓不支持**。 +pub async fn bill_rule_import( + State(state): State, + headers: HeaderMap, + _body: Bytes, +) -> Json { + if let Err(resp) = guard(&state, &headers, EN_BILL_RULE).await { + return resp; + } + fail(code::FAIL, "本仓未配置文件服务,暂不支持导入") +} + #[cfg(test)] mod tests { use super::*; diff --git a/src/backend/src/platform/seed.rs b/src/backend/src/platform/seed.rs index b1c89c5..4ac8512 100644 --- a/src/backend/src/platform/seed.rs +++ b/src/backend/src/platform/seed.rs @@ -160,6 +160,9 @@ pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite // 🔴 消息业务分类字典(`base_business_category`):消息记录页左侧两级页签的数据源。 // 缺了它页面只是「页签为空」,不报错 ⇒ 很容易一直没人发现,所以放在同一处种。 ensure_business_category(db, &now).await?; + // 🔴 `businessType` 字典:单据规则(模板中心)的「业务分类」列/下拉的唯一数据源。 + // 同样是「缺了不报错、只是全空」的那类,一并种在这里。 + ensure_business_type_dict(db, &now).await?; Ok(()) } @@ -334,6 +337,121 @@ pub async fn ensure_business_category(db: &Db, now: &str) -> Result<(), pglite:: Ok(()) } +/// `businessType`(**业务分类**)字典的数据行 —— 官方初始库的 13 行原样。 +/// +/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 里 +/// `f_dictionary_type_id = '306427078100678661'` 的那 13 条 `base_dictionary_data`。 +/// +/// 🔴 **为什么要灌它**:单据规则的 `f_category` 存的就是这些 id +/// (`BillRuleController.list` 只是把 id 换成 `f_full_name` 显示), +/// 字典为空 ⇒ 列表「业务分类」列全空、新建表单的分类下拉一个选项都没有。 +/// 🔴 id 沿用官方字面量:`f_category` 存 id,换 id 官方数据就对不上分类。 +const BUSINESS_TYPES: [(&str, &str, &str); 13] = [ + ("802fb04ab5b84aa5bcc5dc53372a271d", "费用相关", "costRelated"), + ("8f65bbe3bce341c8b3625d93544a044a", "仓库管理", "warehouseManagement"), + ("972acb74d15e493aae4f471e16518bef", "人事管理", "personnelManage"), + ("9b077e268d4f44e6baa29bb40345f422", "项目管理", "projectManage"), + ("9e9205fb43da4b88a24bb1eebd626ff0", "销售管理", "saleManage"), + ("be6b516477ed41dab4d0777336e58ddf", "日常工作", "routine"), + ("c92985dbcdd648c6a98b272a8f09698e", "服务支持", "serviceSupport"), + ("ce51233654ee4d1890c7c081a04da2be", "资产管理", "assetsManage"), + ("e17e977fe98e43d0baabb327f70e6549", "车辆管理", "cheliang"), + ("e43a773b8a024d109dfb176e99f08a35", "行政管理", "administrationManage"), + ("e8bfa8ac60d34361b815b48c494f3e06", "合同管理", "contractManage"), + ("f8b87124ef2a45758426c7d76afa2c90", "公文管理", "documentManage"), + ("fe72535365154b5f82fd7c2f984087f3", "CRM应用", "crm"), +]; + +/// `businessType` 字典**分类**行的固定 id(官方初始库同值)。 +const BUSINESS_TYPE_DICT_ID: &str = "306427078100678661"; + +/// 灌 `businessType` 字典(分类 1 行 + 数据 13 行)—— 幂等,按 `f_id` 判存在。 +/// +/// 🔴 与 [`ensure_business_category`] 同一口径:**不看 `f_delete_mark`** +/// ⇒ 管理员在 UI 里删掉的分类不会被下次启动又插回来。 +pub async fn ensure_business_type_dict(db: &Db, now: &str) -> Result<(), pglite::Error> { + let now = now.to_string(); + let tenant_id = "0".to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + let sort_zero = "0".to_string(); + let parent_zero = "0".to_string(); + let dict_id = BUSINESS_TYPE_DICT_ID.to_string(); + let dict_name = "业务分类".to_string(); + let dict_code = "businessType".to_string(); + let is_tree = "0".to_string(); + let dict_type = "1".to_string(); + + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_dictionary_type WHERE f_id = $1::text LIMIT 1", + &[&dict_id], + ) + .await?; + if existed.is_empty() { + let params: [&(dyn ToSql + Sync); 11] = [ + &dict_id, + &parent_zero, + &dict_name, + &dict_code, + &is_tree, + &dict_type, + &enabled_mark, + &sort_zero, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_dictionary_type \ + (f_id, f_parent_id, f_full_name, f_en_code, f_is_tree, f_type, f_enabled_mark, \ + f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, \ + $6::text::integer, $7::text::integer, $8::text::bigint, \ + $9::text::integer, $10::text, $11::text::timestamp)", + ¶ms, + ) + .await?; + } + + for (index, (id, full_name, en_code)) in BUSINESS_TYPES.iter().enumerate() { + let (id, full_name, en_code) = + (id.to_string(), full_name.to_string(), en_code.to_string()); + let sort_code = index.to_string(); + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_dictionary_data WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 10] = [ + &id, + &parent_zero, + &full_name, + &en_code, + &enabled_mark, + &dict_id, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_dictionary_data \ + (f_id, f_parent_id, f_full_name, f_en_code, f_enabled_mark, f_dictionary_type_id, \ + f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ + $7::text::bigint, $8::text::integer, $9::text, $10::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + /// 把一个 `App-Code`(`base_system.f_en_code`)解析成系统 id(`base_system.f_id`)。 /// /// 🔴 用于把菜单种进正确的系统(`f_system_id`)—— 平台层**不认**具体 app 名, diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index 85b62f3..17cdd59 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -292,6 +292,70 @@ pub fn build_router(state: AppState) -> axum::Router { "/api/message/Notice/{id}/ReplyUserList", get(face_b::notice_reply_user_list), ) + // ---- 系统日志(sysLog 四个页面 + 个人中心登录日志)---- + // 🔴 `Log/deleteLoginLog` / `Log/ModuleName` 是静态段,matchit 里**优先于** + // `Log/{id}` 参数段 ⇒ 两条同时存在也不会互相抢(以测试钉住)。 + // 🔴 `/Log/{id}` 上同时挂 GET(详情)与 DELETE(按分类一键清空)—— + // 官方也是这么复用的(`@DeleteMapping("/{type}")` + `@GetMapping("/{id}")`), + // 段名必须统一写 `{id}`(matchit 不允许同一位置两个不同的参数名)。 + .route("/api/system/Log", get(face_b::log_list)) + .route("/api/system/Log", delete(face_b::log_delete)) + .route("/api/system/Log/deleteLoginLog", delete(face_b::log_clear_login)) + .route("/api/system/Log/ModuleName", get(face_b::log_module_name)) + .route("/api/system/Log/{id}", delete(face_b::log_clear)) + .route("/api/system/Log/{id}", get(face_b::log_info)) + // ---- 审批常用语(模板中心 / 常用语)---- + .route("/api/system/CommonWords", get(face_b::common_words_list)) + .route("/api/system/CommonWords", post(face_b::common_words_create)) + .route( + "/api/system/CommonWords/Selector", + get(face_b::common_words_selector), + ) + .route( + "/api/system/CommonWords/UsesNum", + post(face_b::common_words_uses_num), + ) + .route( + "/api/system/CommonWords/{id}", + get(face_b::common_words_info), + ) + .route( + "/api/system/CommonWords/{id}", + put(face_b::common_words_update), + ) + .route( + "/api/system/CommonWords/{id}", + delete(face_b::common_words_delete), + ) + // ---- 单据规则(模板中心 / 单据规则 + 各种「自动单号」)---- + .route("/api/system/BillRule", get(face_b::bill_rule_list)) + .route("/api/system/BillRule", post(face_b::bill_rule_create)) + .route( + "/api/system/BillRule/Selector", + get(face_b::bill_rule_selector), + ) + .route( + "/api/system/BillRule/BillNumber/{enCode}", + get(face_b::bill_rule_number), + ) + .route( + "/api/system/BillRule/Actions/Import", + post(face_b::bill_rule_import), + ) + .route("/api/system/BillRule/{id}", get(face_b::bill_rule_info)) + .route("/api/system/BillRule/{id}", put(face_b::bill_rule_update)) + .route( + "/api/system/BillRule/{id}", + delete(face_b::bill_rule_delete), + ) + .route( + "/api/system/BillRule/{id}/Actions/State", + put(face_b::bill_rule_state), + ) + .route( + "/api/system/BillRule/{id}/Actions/Export", + get(face_b::bill_rule_export), + ) // ---- 系统配置 + 第三方同步(官方 `SysConfigController` / `SynThirdInfoController`)---- .route("/api/system/SysConfig", get(face_b::sys_config_get)) .route("/api/system/SysConfig", put(face_b::sys_config_update)) @@ -1084,7 +1148,7 @@ mod tests { // 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与 // 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES // + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。 - assert_eq!(body["tables"], 29); + assert_eq!(body["tables"], 32); assert_eq!(body["version"], env!("CARGO_PKG_VERSION")); } @@ -1099,7 +1163,7 @@ mod tests { let port = serve(new_state(db().await)).await; // 🔴 按**路径**列(同一路径多个方法只算一条)—— 每条都用 PATCH 探 405。 - const FACE_B_REGISTERED: [&str; 147] = [ + const FACE_B_REGISTERED: [&str; 162] = [ "/api/permission/Users", "/api/permission/Users/any-id", "/api/permission/Users/BatchDelete", @@ -1249,6 +1313,23 @@ mod tests { "/api/message/Notice/any-id", "/api/message/Notice/any-id/Actions/Release", "/api/message/Notice/any-id/ReplyUserList", + // —— 系统日志 + 审批常用语 + 单据规则(批次 5)—— + // 🔴 `/Log/any-id` 一条覆盖两个方法(GET 详情 / DELETE 按分类清空)。 + "/api/system/Log", + "/api/system/Log/deleteLoginLog", + "/api/system/Log/ModuleName", + "/api/system/Log/any-id", + "/api/system/CommonWords", + "/api/system/CommonWords/Selector", + "/api/system/CommonWords/UsesNum", + "/api/system/CommonWords/any-id", + "/api/system/BillRule", + "/api/system/BillRule/Selector", + "/api/system/BillRule/BillNumber/any-param", + "/api/system/BillRule/Actions/Import", + "/api/system/BillRule/any-id", + "/api/system/BillRule/any-id/Actions/State", + "/api/system/BillRule/any-id/Actions/Export", ]; for path in FACE_B_REGISTERED { diff --git a/src/backend/tests/batch5_it.rs b/src/backend/tests/batch5_it.rs new file mode 100644 index 0000000..f59dd63 --- /dev/null +++ b/src/backend/tests/batch5_it.rs @@ -0,0 +1,651 @@ +//! 批次 5(系统日志 `/api/system/Log` + 审批常用语 `/api/system/CommonWords` + +//! 单据规则 `/api/system/BillRule`)集成测试。 +//! +//! 🔴 **钉住的契约点**(每条都对应官方控制器 / mapper 的一处硬要求): +//! ① `GET /Log?category=1` 是 `PageListVO`,`creatorTime` 是**毫秒数**(官方 VO 是 `Long`); +//! `category=2`(访问日志)官方走 `default` ⇒ **必须 400**,不是空列表。 +//! ② 登录**会落 `base_sys_log`**(`f_type=1`):`loginMark=1`、`browser`/`platForm` 从 UA 粗分 +//! ⇒ 个人中心 `Users/Current/SystemLog` 才有内容(早先恒空、也不报错)。 +//! ③ `DELETE /Log/{type}` 按**分类**清空(`type` 是分类号不是 id), +//! `DELETE /Log/deleteLoginLog` 只清**自己的** —— 两条语义不同,不能合并。 +//! ④ 常用语:`text + type` 同档判重(`SYS105`)、`UsesNum` 按**文本**累加。 +//! ⑤ 单据规则的单号生成三分支 + **跨天归零**:上一号的日期段 ≠ 今天 ⇒ 从 0 重来。 +//! ⑥ 已发过号的规则**不许删**(`SYS003`);导出/导入本仓无文件服务 ⇒ 明确 400。 +//! +//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。 + +use std::path::PathBuf; +use std::sync::Arc; + +use serde_json::{json, Value}; +use ssw_platform::bootstrap::ensure_base; +use ssw_platform::platform::config::Config; +use ssw_platform::platform::db::{pglite::ToSql, 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 +} + +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 +} + +/// 面 B 请求(带 `Vue-Version: 3`)。 +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) +} + +/// 登录(**带 User-Agent**:登录日志的「浏览器 / 操作系统」两列靠它)。 +async fn login(port: u16) -> String { + let enc = ssw_platform::platform::cipher::encrypt_password("123456"); + let payload = format!("account=admin&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\ + User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 \ + (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36\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() +} + +fn new_state(db: &Db) -> AppState { + AppState { + config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch5-it"))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + } +} + +/// 取「今天」的 `YYYYMMDD`(与后端 `to_char(now(), 'YYYYMMDD')` 同一来源:库里算)。 +async fn today_ymd(db: &Db) -> String { + let rows = db + .query_json_params("SELECT to_char(now(), 'YYYYMMDD') AS \"d\"", &[]) + .await + .expect("取日期失败"); + rows[0]["d"].as_str().unwrap_or_default().to_string() +} + +// ---------------------------------------------------------------- 系统日志 + +/// 登录落库 ⇒ `/api/system/Log` 与个人中心「登录日志」都看得到同一条。 +#[tokio::test] +async fn login_writes_log_and_both_readers_agree() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // ① 登录日志列表:形状是 PageListVO,`creatorTime` 是毫秒数。 + let (_, listed) = call(port, "GET", "/api/system/Log?category=1", &token, None).await; + assert_eq!(listed["code"], 200, "登录日志列表失败: {listed}"); + let pagination = listed["data"]["pagination"] + .as_object() + .unwrap_or_else(|| panic!("data 必须是 PageListVO: {listed}")); + assert!(pagination.contains_key("total"), "必须有 total: {listed}"); + let rows = listed["data"]["list"].as_array().expect("必须有 list"); + assert!(!rows.is_empty(), "登录过就必须有登录日志: {listed}"); + let row = rows.first().expect("至少一行"); + assert_eq!(row["loginMark"], json!(1), "成功登录 ⇒ loginMark=1: {row}"); + assert_eq!(row["loginType"], json!(0), "登录 ⇒ loginType=0: {row}"); + assert_eq!(row["userName"], json!("管理员"), "用户名取 realName: {row}"); + assert_eq!(row["browser"], json!("Chrome"), "UA 应分出 Chrome: {row}"); + assert_eq!(row["platForm"], json!("macOS"), "UA 应分出 macOS: {row}"); + assert_eq!(row["ipAddress"], json!("127.0.0.1"), "默认回环: {row}"); + // 🔴 毫秒时间戳(官方 LoginLogVO.creatorTime 是 Long)—— 13 位量级。 + let ts = row["creatorTime"].as_i64().expect("必须是数字"); + assert!(ts > 1_600_000_000_000, "必须是毫秒时间戳,实际 {ts}"); + + // ② 个人中心那条读的是同一张表(同一个用户 ⇒ 同样有行)。 + let (_, mine) = call( + port, + "GET", + "/api/permission/Users/Current/SystemLog", + &token, + None, + ) + .await; + assert_eq!(mine["code"], 200, "个人中心登录日志失败: {mine}"); + let mine_total = mine["data"]["pagination"]["total"].as_i64().unwrap_or(0); + assert!(mine_total >= 1, "个人中心也该看到自己的登录日志: {mine}"); + + // ③ 访问日志(category=2)官方走 default ⇒ 400,不是空列表。 + let (_, denied) = call(port, "GET", "/api/system/Log?category=2", &token, None).await; + assert_eq!(denied["code"], json!(400), "category=2 必须 400: {denied}"); +} + +/// 三条删除路径的**语义差别**:按 id 删 / 按分类清空 / 只清自己的。 +#[tokio::test] +async fn log_delete_paths_have_distinct_semantics() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + // 先清干净,计数才有确定性。 + let (_, cleared) = call(port, "DELETE", "/api/system/Log/1", &token, None).await; + assert_eq!(cleared["code"], 200, "一键清空失败: {cleared}"); + let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await; + assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}"); + + // ① 按 id 批量删。 + let _ = login(port).await; + let (_, listed) = call(port, "GET", "/api/system/Log?category=1", &token, None).await; + let id = listed["data"]["list"][0]["id"] + .as_str() + .expect("日志必须有 id") + .to_string(); + let body = json!({ "ids": [id] }).to_string(); + let (_, deleted) = call(port, "DELETE", "/api/system/Log", &token, Some(&body)).await; + assert_eq!(deleted["code"], 200, "按 id 删除失败: {deleted}"); + let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await; + assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}"); + + // ② 只清自己的(`deleteLoginLog`)—— 自己的删掉就归零。 + let _ = login(port).await; + let (_, mine_del) = call(port, "DELETE", "/api/system/Log/deleteLoginLog", &token, None).await; + assert_eq!(mine_del["code"], 200, "清空个人登录日志失败: {mine_del}"); + let (_, after) = call(port, "GET", "/api/system/Log?category=1", &token, None).await; + assert_eq!(after["data"]["pagination"]["total"], json!(0), "{after}"); +} + +// ---------------------------------------------------------------- 审批常用语 + +/// 常用语:判重 / 列表 / 下拉 / 使用计数 / 改 / 删。 +#[tokio::test] +async fn common_words_crud_and_uses_num() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + let text = "同意,请按计划推进"; + + let body = json!({ "commonWordsText": text, "commonWordsType": 0, "enabledMark": 1 }); + let (_, created) = call( + port, + "POST", + "/api/system/CommonWords", + &token, + Some(&body.to_string()), + ) + .await; + assert_eq!(created["code"], 200, "新建常用语失败: {created}"); + + // ① 同文本同类型 ⇒ `SYS105 常用语已存在`。 + let (_, dup) = call( + port, + "POST", + "/api/system/CommonWords", + &token, + Some(&body.to_string()), + ) + .await; + assert_eq!(dup["code"], json!(400), "重复必须 400: {dup}"); + assert_eq!(dup["msg"], json!("常用语已存在"), "{dup}"); + + // ② 列表(公共 type=0)能查到,且形状是 PageListVO。 + let (_, listed) = call( + port, + "GET", + "/api/system/CommonWords?commonWordsType=0¤tPage=1&pageSize=20", + &token, + None, + ) + .await; + assert_eq!(listed["code"], 200, "常用语列表失败: {listed}"); + let row = listed["data"]["list"] + .as_array() + .expect("PageListVO") + .iter() + .find(|x| x["commonWordsText"] == json!(text)) + .unwrap_or_else(|| panic!("新建的常用语必须在列表里: {listed}")) + .clone(); + let id = row["id"].as_str().expect("必须有 id").to_string(); + assert_eq!(row["commonWordsType"], json!(0), "{row}"); + + // ③ 下拉:`ListVO`(只有 list)。 + let (_, selector) = call( + port, + "GET", + "/api/system/CommonWords/Selector?type=0", + &token, + None, + ) + .await; + assert_eq!(selector["code"], 200, "常用语下拉失败: {selector}"); + assert!( + selector["data"].get("pagination").is_none(), + "Selector 是 ListVO,不该有 pagination: {selector}" + ); + + // ④ 使用计数:按**文本**加。 + let uses = json!({ "commonWordsText": text }).to_string(); + let (_, counted) = call( + port, + "POST", + "/api/system/CommonWords/UsesNum", + &token, + Some(&uses), + ) + .await; + assert_eq!(counted["code"], 200, "计数失败: {counted}"); + let (_, info) = call(port, "GET", &format!("/api/system/CommonWords/{id}"), &token, None).await; + assert_eq!(info["data"]["usesNum"], json!(1), "计数应 +1: {info}"); + assert!(info["data"]["systemNames"].is_string(), "详情要补 systemNames: {info}"); + + // ⑤ 改:只 SET body 出现的键(这里只改文本)。 + let patch = json!({ "commonWordsText": "同意,按计划推进(修订)" }).to_string(); + let (_, updated) = call( + port, + "PUT", + &format!("/api/system/CommonWords/{id}"), + &token, + Some(&patch), + ) + .await; + assert_eq!(updated["code"], 200, "修改失败: {updated}"); + let (_, info) = call(port, "GET", &format!("/api/system/CommonWords/{id}"), &token, None).await; + assert_eq!(info["data"]["commonWordsText"], json!("同意,按计划推进(修订)"), "{info}"); + assert_eq!(info["data"]["enabledMark"], json!(1), "没给的键不能被清空: {info}"); + + // ⑥ 删(软删)⇒ 列表里没了。 + let (_, deleted) = call( + port, + "DELETE", + &format!("/api/system/CommonWords/{id}"), + &token, + None, + ) + .await; + assert_eq!(deleted["code"], 200, "删除失败: {deleted}"); + let (_, listed) = call( + port, + "GET", + "/api/system/CommonWords?commonWordsType=0", + &token, + None, + ) + .await; + assert!( + listed["data"]["list"] + .as_array() + .expect("PageListVO") + .iter() + .all(|x| x["id"] != json!(id)), + "软删后不该再出现: {listed}" + ); +} + +// ---------------------------------------------------------------- 单据规则 + +/// 单号生成:时间格式 + 位数补零 + **跨天归零**;`f_this_number` 会回写。 +#[tokio::test] +async fn bill_number_time_format_and_day_reset() { + let _guard = LOCK.lock().await; + let db = db().await; + let port = serve(new_state(db)).await; + let token = login(port).await; + let ymd = today_ymd(db).await; + + let body = json!({ + "fullName": "测试单号-时间格式", + "enCode": "biz_test_no", + "category": "9b077e268d4f44e6baa29bb40345f422", + "prefix": "SO", + "type": 1, + "dateFormat": "YYYYMMDD", + "digit": 4, + "startNumber": "1", + }); + let (_, created) = call( + port, + "POST", + "/api/system/BillRule", + &token, + Some(&body.to_string()), + ) + .await; + assert_eq!(created["code"], 200, "新建单据规则失败: {created}"); + + // ① 第一次发号:起始值 1 ⇒ `SO{今天}0001`。 + let (_, first) = call( + port, + "GET", + "/api/system/BillRule/BillNumber/biz_test_no", + &token, + None, + ) + .await; + assert_eq!(first["code"], 200, "发号失败: {first}"); + assert_eq!( + first["data"], + json!(format!("SO{ymd}0001")), + "第一次发号应等于 前缀+日期+起始值补零: {first}" + ); + + // ② 第二次:连续递增(**同一天**不清零)。 + let (_, second) = call( + port, + "GET", + "/api/system/BillRule/BillNumber/biz_test_no", + &token, + None, + ) + .await; + assert_eq!(second["data"], json!(format!("SO{ymd}0002")), "{second}"); + + // ③ 跨天归零:把上一号伪造成「去年 1 月 1 日的 0009」⇒ 下次必须回到 0001。 + let sql = "UPDATE base_bill_rule SET f_output_number = $1::text, \ + f_this_number = $2::text::integer WHERE f_en_code = 'biz_test_no'"; + let values = [Some("SO202001010009".to_string()), Some("9".to_string())]; + let params: Vec<&(dyn ToSql + Sync)> = + values.iter().map(|v| v as &(dyn ToSql + Sync)).collect(); + db.exec_params(sql, ¶ms).await.expect("伪造上一号失败"); + let (_, reset) = call( + port, + "GET", + "/api/system/BillRule/BillNumber/biz_test_no", + &token, + None, + ) + .await; + assert_eq!( + reset["data"], + json!(format!("SO{ymd}0001")), + "日期段变了就必须从起始值重来: {reset}" + ); + + // ④ 列表:`category` 要换成字典里的**中文名**(`businessType` 项目管理)。 + let (_, listed) = call(port, "GET", "/api/system/BillRule", &token, None).await; + assert_eq!(listed["code"], 200, "单据规则列表失败: {listed}"); + let row = listed["data"]["list"] + .as_array() + .expect("PageListVO") + .iter() + .find(|x| x["enCode"] == json!("biz_test_no")) + .unwrap_or_else(|| panic!("新建的规则必须在列表里: {listed}")) + .clone(); + assert_eq!(row["category"], json!("项目管理"), "分类要显示中文名: {row}"); + assert_eq!(row["creatorUser"], json!("管理员/admin"), "创建人=姓名/账号: {row}"); + assert_eq!(row["outputNumber"], json!(format!("SO{ymd}0001")), "{row}"); +} + +/// 单据规则的几道闸:判重 / 已用不许删 / 导出导入明确不支持 / 改规则清流水。 +#[tokio::test] +async fn bill_rule_guards() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + let body = json!({ + "fullName": "测试单号-闸门", + "enCode": "biz_guard_no", + "category": "9b077e268d4f44e6baa29bb40345f422", + "prefix": "GD", + "type": 1, + "dateFormat": "YYYYMMDD", + "digit": 3, + "startNumber": "1", + }); + let (_, created) = call( + port, + "POST", + "/api/system/BillRule", + &token, + Some(&body.to_string()), + ) + .await; + assert_eq!(created["code"], 200, "新建失败: {created}"); + + // ① 名称重复 ⇒ `EXIST001 名称不能重复`。 + let mut dup_name = body.clone(); + dup_name["enCode"] = json!("biz_guard_no_2"); + let (_, dup) = call( + port, + "POST", + "/api/system/BillRule", + &token, + Some(&dup_name.to_string()), + ) + .await; + assert_eq!(dup["code"], json!(400), "{dup}"); + assert_eq!(dup["msg"], json!("名称不能重复"), "{dup}"); + + // ② 编码重复 ⇒ `EXIST002 编码不能重复`。 + let mut dup_code = body.clone(); + dup_code["fullName"] = json!("测试单号-闸门2"); + let (_, dup) = call( + port, + "POST", + "/api/system/BillRule", + &token, + Some(&dup_code.to_string()), + ) + .await; + assert_eq!(dup["msg"], json!("编码不能重复"), "{dup}"); + + // ③ 发一次号 ⇒ 之后不许删(`SYS003`)。 + let (_, numbered) = call( + port, + "GET", + "/api/system/BillRule/BillNumber/biz_guard_no", + &token, + None, + ) + .await; + assert_eq!(numbered["code"], 200, "{numbered}"); + let (_, listed) = call( + port, + "GET", + "/api/system/BillRule?keyword=biz_guard_no", + &token, + None, + ) + .await; + let id = listed["data"]["list"][0]["id"] + .as_str() + .expect("必须有 id") + .to_string(); + let (_, blocked) = call( + port, + "DELETE", + &format!("/api/system/BillRule/{id}"), + &token, + None, + ) + .await; + assert_eq!(blocked["code"], json!(400), "已发号不许删: {blocked}"); + assert_eq!(blocked["msg"], json!("单据已经被使用,不允许被删除"), "{blocked}"); + + // ④ 导出/导入:本仓无文件服务 ⇒ 明确 400(不假装成功)。 + let (_, exported) = call( + port, + "GET", + &format!("/api/system/BillRule/{id}/Actions/Export"), + &token, + None, + ) + .await; + assert_eq!(exported["code"], json!(400), "{exported}"); + let (_, imported) = call( + port, + "POST", + "/api/system/BillRule/Actions/Import", + &token, + Some("{}"), + ) + .await; + assert_eq!(imported["code"], json!(400), "{imported}"); + + // ⑤ 改「位数」= 生成规则变了 ⇒ 流水号状态清空(thisNumber 归 0、outputNumber 归 null)。 + let patch = json!({ "digit": 5 }).to_string(); + let (_, updated) = call( + port, + "PUT", + &format!("/api/system/BillRule/{id}"), + &token, + Some(&patch), + ) + .await; + assert_eq!(updated["code"], 200, "修改失败: {updated}"); + let (_, info) = call( + port, + "GET", + &format!("/api/system/BillRule/{id}"), + &token, + None, + ) + .await; + assert_eq!(info["data"]["digit"], json!(5), "{info}"); + assert_eq!(info["data"]["thisNumber"], json!(0), "改位数应清空流水: {info}"); + assert!(info["data"]["outputNumber"].is_null(), "改位数应清空上一号: {info}"); + + // ⑥ 清空后就能删了。 + let (_, deleted) = call( + port, + "DELETE", + &format!("/api/system/BillRule/{id}"), + &token, + None, + ) + .await; + assert_eq!(deleted["code"], 200, "清空流水后应可删: {deleted}"); +} + +/// 随机数 / UUID 两个分支:位数对得上、两次不同。 +#[tokio::test] +async fn bill_number_random_and_uuid() { + let _guard = LOCK.lock().await; + let port = serve(new_state(db().await)).await; + let token = login(port).await; + + for (en_code, kind, extra) in [ + ("biz_random_no", 2, json!({ "randomDigit": 6, "randomType": 1 })), + ("biz_uuid_no", 3, json!({})), + ] { + let mut body = json!({ + "fullName": format!("测试单号-{en_code}"), + "enCode": en_code, + "category": "9b077e268d4f44e6baa29bb40345f422", + "prefix": "R", + "type": kind, + "dateFormat": "no", + "digit": 1, + "startNumber": "1", + }); + if let Some(obj) = extra.as_object() { + for (k, v) in obj { + body[k] = v.clone(); + } + } + let (_, created) = call( + port, + "POST", + "/api/system/BillRule", + &token, + Some(&body.to_string()), + ) + .await; + assert_eq!(created["code"], 200, "新建 {en_code} 失败: {created}"); + + let path = format!("/api/system/BillRule/BillNumber/{en_code}"); + let (_, first) = call(port, "GET", &path, &token, None).await; + let (_, second) = call(port, "GET", &path, &token, None).await; + assert_eq!(first["code"], 200, "{en_code} 发号失败: {first}"); + let a = first["data"].as_str().unwrap_or_default().to_string(); + let b = second["data"].as_str().unwrap_or_default().to_string(); + assert!(a.starts_with('R'), "{en_code} 必须带前缀: {a}"); + assert_ne!(a, b, "{en_code} 两次发号不该相同: {a} / {b}"); + if kind == 2 { + assert_eq!(a.chars().count(), 1 + 6, "随机数位数应 = prefix 1 + randomDigit 6: {a}"); + assert!( + a.chars().skip(1).all(|c| c.is_ascii_digit()), + "randomType=1 ⇒ 数字: {a}" + ); + } else { + // UUID 大写、带连字符(官方 `IdUtil.randomUUID().toUpperCase()`)。 + assert_eq!(a.chars().count(), 1 + 36, "UUID 应是 36 位(带连字符): {a}"); + assert_eq!(a, a.to_uppercase(), "UUID 必须大写: {a}"); + } + } +}