diff --git a/.workbuddy/memory/2026-11-03.md b/.workbuddy/memory/2026-11-03.md index 8e25867..4501657 100644 --- a/.workbuddy/memory/2026-11-03.md +++ b/.workbuddy/memory/2026-11-03.md @@ -78,3 +78,14 @@ - **新增防回退闸门**:**AR10**(平台层不许 `use crate::platform::compat`)= 拆 crate 的前置条件;**AR11**(契约面底座 helper 不许 `use super::<非helper>`)= 14 个模块依赖它 ⇒ 反向依赖即成环。**反自证从 4 条扩到 6 条**(5/6 造 `use crate::platform::compat::helper::current_user`;6/6 备份 helper.rs 后追加 `use super::system::menu_node` 再还原)。 - **数字**:`cargo build --workspace` 零警告;`cargo test --workspace` **695 passed / 0 failed**(与基线**完全一致**);`check-arch.sh` **14/14**;`check-arch.sh --self-test` **6/6**;`check-boundary.sh` 11/11;`check-contract.sh` 10/10;`check-module.sh` 123/123;`check-citations.sh` 4/4;`verify.sh --smoke` 14 步全绿(478.2s)。 - ⏭ **下一步 = M2(`sspf-core` 平台核心下沉)**:迁 `platform/{auth,session,authorization,crud,sys,menu,guard,monitor,registry,state,seed,variate_catalog}.rs` + `{cipher,envelope,ids,config,db}.rs`。**关键是保留 `platform/*.rs` 作为 `pub use sspf_core::*` 转发壳** ⇒ 上层零感知、695 个测试**不用改 import**。 + +### 13:20–14:50 M2 完成:平台核心 19 模块下沉 `crates/sspf-core/`(tag v0.1.2-m2) + +- **触发**:继续执行 `docs/CRATES-MIGRATION.md` 的 M2(平台核心下沉)。 +- **做法**:`platform/` 下 19 个模块 `git mv` 进 `crates/sspf-core/src/`(保留历史);`src/backend/src/platform/*.rs` 全改成 `pub use sspf_core::::*;` 转发壳 ⇒ **上层零感知**(routes / modules / 695 测试的 import 一个没改)。crate 内路径改写 `crate::platform::X` → `crate::X`(compat 除外)。 +- 🔴 **又一次验证「最大风险不是代码,是闸门」**:搬迁后 `platform/` 只剩转发壳(无函数体)⇒ 闸门扫空壳 = 虚假安全感。**实测当场暴露 3 处**:① `check-contract.sh` 反自证报警「守卫写错没被 CC6 抓到」(`plat_files` 收不到函数体);② `check-boundary.sh` CP6 报「BUILTIN_MENUS 有 0 条」(读空壳 seed.rs);③ `check-module.sh` 8 项软删检查全 ❌(crud.rs 无 SQL 可 grep)。**幸好反自证起作用了** —— 尺子没静默失效。 +- 🔴 **闸门改造的核心纪律 = 「两处都扫」**:真源 `crates/sspf-core/src/`(管实现)+ 转发壳(防塞私货)。改了 6 处:`check-arch.sh` AR9/AR10(扫描两处)+ **反自证 2/6、5/6 两处都注入探针、且按路径分别验**(单点注入会漏判 —— 一开始我用 `grep -q "__ar9_selftest"` 不分路径,单处抓到会误判成两处都抓到,已改);`check-boundary.sh` 新增 `PLATFORM_CORE`、CP1/CP2 两处扫、CP6 改读真源;`check-contract-scan.py` 的 `plat_files` 两处都收、**重名键拼接而非覆盖**(覆盖会丢函数 ⇒ 推不出守卫);`check-module.sh` `CRUD` 改读真源;`gen-function-catalog.py` `OUT` 改写真源(否则**覆盖转发壳** ⇒ 上层 import 全断)。 +- **反向验证**(证明闸门真在扫真源,不是碰巧通过):只往 `crates/sspf-core/src/` 塞 `use sspf_pack_asset::…` / `use crate::platform::compat::…` ⇒ AR9/AR10 **都报红**;探针已清干净。 +- **与原计划的差异**:① `pub(crate)` → `pub`(10 处):跨 crate 后失效;② `crud.rs` 3 个测试原依赖 `crate::modules::all_specs()`(业务层)⇒ 改用**契约层合成 spec** 参数化测试,顺带发现**技术债**:`write_cast` 的 numeric 映射是**列名枚举**(`f_price`/`f_stock`)而非 spec 声明 ⇒ 新表带 `f_amount` 会静默缺 `::numeric`;③ `registry.rs` 测试改自建库 + `seed::ensure_base(db, &[])`;④ `test_support.rs` 留壳层(依赖装配根的业务 DDL)。 +- **数字**:转发壳每文件 ≤ 10 行;`cargo build` 零警告;`cargo test` **695 passed / 0 failed**(与基线一致);`check-arch` 14/14;`--self-test` 6/6;`check-boundary` 11/11;`check-contract` 10/10(反自证 12 例全过);`check-module` 123/123;`check-citations` 4/4;`verify.sh --smoke` 14 步全绿(512.3s)。 +- ⏭ **下一步 = M3(`sspf-compat-core`)**:迁 `compat/helper.rs`(902) + `compat/res.rs`(460)。M2 的「转发壳 + 闸门扫真源 + 反自证两处注入」套路直接复用。⚠️ M4 之后必须做 `check-contract-scan.py` 的 compat 包收编 + 重跑 `--self-test`。 diff --git a/CLAUDE.md b/CLAUDE.md index a110d36..c8fe0cb 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -100,6 +100,8 @@ ssw-platform/ │ ├── sspf-sdk/ # 🔴 业务包唯一依赖:BusinessPack trait + Manifest │ │ # 依赖只能是 sspf-contract(AR1) │ ├── sspf-store/ # (P0-b)DB 抽象:pglite ⇄ 真实 PG +│ ├── sspf-core/ # 🔴 平台核心(M2):auth/CRUD/权限/种子/cipher/信封/… +│ │ # `src/backend/src/platform/*.rs` 只是它的转发壳 │ ├── sspf-lowcode/ # (P2)元数据引擎 + Rhai 沙箱 │ ├── sspf-plugin/ # (P3)业务包加载器:静态 / dylib / wasm │ └── sspf-mcp/ # (P1)MCP 2.0 元工具层 @@ -112,19 +114,12 @@ ssw-platform/ │ │ ├── src/ │ │ │ ├── main.rs # 启动装配 │ │ │ ├── lib.rs # pub mod platform / modules / routes -│ │ │ ├── platform/ # 【平台层】契约实现,加业务模块一个字都不改 -│ │ │ │ ├── cipher.rs # md5→AES-256-ECB(key=md5("EY8WePvjM5GGwQzn") 的 32 ASCII 字节)→hex -│ │ │ │ ├── envelope.rs# ActionResult{code,msg,data} -│ │ │ │ ├── auth.rs # 登录 / CurrentUser / 登录守卫(面 A/面 B 共用) -│ │ │ │ ├── face_b.rs # 【面 B】基线平台形状:判别头 / PcUserVO / PageListVO / 点权限守卫 -│ │ │ │ │ # (P0 由 jnpf.rs 改名:内部标识必须剥离,前端不依赖) -│ │ │ │ ├── permission.rs # 四源合并 + 管理员短路 + 菜单树(全部按 f_system_id 隔离) -│ │ │ │ ├── seed.rs # ensureBase(含 ensure_systems)+ firstSeed -│ │ │ │ ├── system.rs # 【多应用】App-Code 头 → SystemRef{id,code};base_system 注册表 -│ │ │ │ ├── sys.rs # 5 组 base_* 显式 handler -│ │ │ │ ├── crud.rs # spec 驱动通用 CRUD 引擎(不含业务表名/app_code) -│ │ │ │ ├── test_support.rs # 测试用**进程级共享** pglite(pglite 每进程只能开一次) -│ │ │ │ └── ...(config/db/ids/session/state/entity/menu/guard/mod) +│ │ │ ├── platform/ # 【平台层】M2 起**真源在 `crates/sspf-core/src/`** +│ │ │ │ │ # 这里每个 .rs 只是转发壳(`pub use sspf_core::::*;`) +│ │ │ │ │ # ⇒ 上层 import 路径不变;别往壳里塞实现(AR9/AR10 会红) +│ │ │ │ ├── compat/ # 【面 B 契约面】尚未下沉(M3/M4)—— 真实现还在这里 +│ │ │ │ ├── test_support.rs # 测试用**进程级共享** pglite(依赖装配根 ⇒ 留壳层) +│ │ │ │ └── mod.rs # 转发壳汇总 │ │ │ ├── modules/ # 【业务层】加业务模块只改这里 │ │ │ │ ├── mod.rs # ALL_SPECS / ALL_MENUS / ALL_ROUTES / router() 汇总 │ │ │ │ ├── demo.rs / shop.rs / books.rs # 模板模块(不进生产) diff --git a/Cargo.lock b/Cargo.lock index 37d34af..28ba79e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1093,6 +1093,26 @@ dependencies = [ "uuid", ] +[[package]] +name = "sspf-core" +version = "0.1.0" +dependencies = [ + "aes", + "axum", + "chrono", + "ecb", + "hex", + "libc", + "md-5 0.10.6", + "rand 0.8.8", + "serde", + "serde_json", + "serde_urlencoded", + "sspf-contract", + "sspf-store", + "tokio", +] + [[package]] name = "sspf-lowcode" version = "0.1.0" @@ -1165,6 +1185,7 @@ dependencies = [ "serde_json", "serde_urlencoded", "sspf-contract", + "sspf-core", "sspf-lowcode", "sspf-mcp", "sspf-pack-asset", diff --git a/HANDOFF.md b/HANDOFF.md index a8198ab..b8f987b 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -88,6 +88,50 @@ helper 被 14 个模块依赖 ⇒ 符号在 helper 里大家都能用; --- +## 0-0-pre3. 2026-11-03 14:50 **M2 完成**:平台核心 19 模块下沉 `crates/sspf-core/`(tag `v0.1.2-m2`) + +**做了什么**:`platform/` 下 19 个模块 `git mv` 进 `crates/sspf-core/src/`(保留历史), +`src/backend/src/platform/*.rs` 全部改成 `pub use sspf_core::::*;` 转发壳 +⇒ **上层零感知**(routes / modules / 695 个测试的 import 一个没改)。 + +**🔴 最大风险不是代码,是闸门(又一次验证了这个判断)**: +搬迁后 `platform/` 只剩转发壳(`pub use`,无函数体)⇒ 闸门扫空壳 = **虚假安全感**。 +实测**当场暴露**: +- `check-contract.sh` 反自证报警「守卫写错**没**被 CC6 抓到」—— `plat_files` 收不到函数体 ⇒ 守卫推不出 +- `check-boundary.sh` CP6 报「BUILTIN_MENUS 有 0 条」—— 读空壳的 `seed.rs` +- `check-module.sh` 8 项软删检查全 ❌ —— `crud.rs` 里没有 SQL 可 grep + +**闸门改造(6 处,都要求「两处都扫」= 真源 `crates/sspf-core/src/` + 转发壳)**: +| 闸门 | 改造 | +|---|---| +| `check-arch.sh` AR9/AR10 | 扫描目录改两处;**反自证 2/6、5/6 两处都注入探针,且按路径分别验**(单点注入会漏判) | +| `check-boundary.sh` | 新增 `PLATFORM_CORE`;CP1/CP2 两处扫;CP6 的 `seed.rs` 改读真源 | +| `check-contract-scan.py` | `plat_files` 两处都收,重名键**拼接**(覆盖会丢函数 ⇒ 推不出守卫) | +| `check-module.sh` | `CRUD` 改读 `crates/sspf-core/src/crud.rs`(软删契约要看 SQL) | +| `gen-function-catalog.py` | `OUT` 改写 `crates/sspf-core/src/variate_catalog.rs`(否则**覆盖转发壳**) | +| `check-arch.sh` 头部注释 | 判据说明同步 M2 路径现实 | + +**反向验证**(证明闸门真在扫真源):只往 `crates/sspf-core/src/` 塞违规 ⇒ AR9/AR10 **都报红**;探针已清干净。 + +**🔴 实际做法与原计划的差异**: +1. **`pub(crate)` → `pub`(10 处)**:跨 crate 后失效 —— `crud::{handle_list,handle_save,handle_delete,handle_*_face_b,value_to_text}` / `auth::{client_ip,parse_user_agent}` / `sys::query_param`。 +2. **测试归属跟着依赖走**:`crud.rs` 3 个测试原依赖 `crate::modules::all_specs()`(业务层)⇒ core 不能反向依赖业务层 ⇒ 改用**契约层合成 spec** 参数化测试(断言强度不降)。顺带发现**技术债**:`write_cast` 的 numeric 映射是**列名枚举**(`f_price`/`f_stock`)而非 spec 声明 ⇒ 新表带 `f_amount` 会静默缺 `::numeric`(现有列名恰好都叫 `f_price` 未暴雷)。 +3. **`registry.rs` 测试自建库**:改 `seed::ensure_base(db, &[])`(不经 `bootstrap`,那是装配根、认识业务层)。 +4. **`test_support.rs` 留壳层**:依赖 `bootstrap::ensure_schema_all`(业务 DDL)⇒ 不进 core。 +5. **路径改写**:crate 内 `crate::platform::X` → `crate::X`(`compat` 除外)。 + +**出口判据(全部达成)**: +转发壳每文件 ≤ 10 行;`cargo build` **零警告**;`cargo test --workspace` = **695 passed / 0 failed**(与基线一致); +`check-arch.sh` = **14/14**;`--self-test` = **6/6**;`check-boundary` 11/11;`check-contract` 10/10(反自证 12 例全过); +`check-module` 123/123;`check-citations` 4/4;`check-naming` 3/0/1; +`verify.sh --smoke` **14 步全绿**(512.3s)。 + +**⏭ 下一步 = M3(`sspf-compat-core` 契约面公共底座)**:迁 `compat/helper.rs`(902) + `compat/res.rs`(460)。 +M2 的「转发壳 + 闸门扫真源 + 反自证两处注入」套路**直接复用**。 +⚠️ M4 之后必须做 `check-contract-scan.py` 的 compat 包收编 + 重跑 `--self-test`。 + +--- + ## 0-0. 2026-11-02 23:13 验证修复轮(官方前端 + dacli 真跑后修的) 用官方 vue 前端 + dacli + 586 条端点探针做过一轮真实系统性验证(报告: diff --git a/crates/sspf-core/Cargo.toml b/crates/sspf-core/Cargo.toml new file mode 100644 index 0000000..0607a9d --- /dev/null +++ b/crates/sspf-core/Cargo.toml @@ -0,0 +1,42 @@ +[package] +name = "sspf-core" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +# 🔴 **平台核心层**(M2 起从 `src/backend/src/platform/` 下沉到这里)。 +# +# 装什么:契约实现(信封 / cipher / 登录 / 会话 / 权限 / `base_*` 管理 / +# CRUD 引擎 / 应用状态)—— 即「平台自带、与业务无关」的那一层。 +# +# 🔴 **依赖纪律**: +# - 允许:契约层(类型与码表)+ 存储层(db / config)+ axum(HTTP 包装) +# + 序列化 + 时间 + 加密原语。 +# - 禁止:**业务包**(`sspf_pack_*`)—— 平台层不许认识任何业务(AR9)。 +# - 禁止:**契约面**(面 B 的 compat)—— 平台层不许反向依赖契约面(AR10)。 +# 装配根(`src/backend/src/routes.rs`)负责按判别头分流。 +# +# 🔴 **为什么允许依赖 axum**:本层是「HTTP 包装层」—— 信封 `Json`、 +# `Router`、extractor 都住在这一层。它**不认识业务**,因此不会把业务包拖进框架。 +[dependencies] +# 契约层(类型 / 码表 / 判别头) +sspf-contract = { path = "../sspf-contract" } +# 存储层(db / config)—— 不认识 HTTP +sspf-store = { path = "../sspf-store" } + +axum = { workspace = true } +tokio = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } +serde_urlencoded = { workspace = true } +# cipher 原语(md5 + AES-256-ECB) +aes = { workspace = true } +ecb = { workspace = true } +md-5 = { workspace = true } +hex = { workspace = true } +# 会话 token 生成 +rand = { workspace = true } +# 时间戳(会话过期 / 种子时间 / 监控采样) +chrono = { workspace = true } +# `monitor.rs` 的 macOS 负载均值读法(`getloadavg`) +libc = { workspace = true } diff --git a/crates/sspf-core/src/auth.rs b/crates/sspf-core/src/auth.rs new file mode 100644 index 0000000..62c4bc9 --- /dev/null +++ b/crates/sspf-core/src/auth.rs @@ -0,0 +1,445 @@ +//! auth —— 登录(`/api/oauth/Login`)、当前用户(`/api/oauth/CurrentUser`)与两个请求守卫。 +//! +//! 契约:规格 §6.1(认证)+ §9(`auth.rs` 接口)。 +//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/auth/`。 +//! +//! 🔴 **三条硬约定**: +//! 1. **业务失败恒 HTTP 200**:登录失败 `code=400`、未登录 `code=600`、无菜单权限 `code=403` +//! —— 全都是**信封里的 code**,不是 HTTP 状态码(**别抄 `tdc-rs` 的裸 401/403**)。 +//! 2. **表单解析失败也要走业务信封**:axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` +//! ⇒ `Option>` 编译不过 ⇒ 登录端点取**原始 body** 自己解析, +//! 解析失败返回 `fail(400, "缺少 account / password")`,**不是** axum 默认的 400 文本。 +//! 3. **口令不得外泄**:请求体里的密文只在内存里比对,响应体里**永不**回显; +//! 库里存的是 `md5(明文)`(`base_user.f_password`)。 + +use axum::body::Bytes; +use axum::extract::State; +use axum::http::HeaderMap; +use axum::Json; +use serde_json::{json, Value}; + +use crate::cipher::decrypt_to_md5; +use crate::db::pglite::ToSql; +use crate::envelope::{fail, ok, ActionResult}; +use crate::authorization::{build_menu_list, has_module}; +use crate::session::TokenUser; +use crate::state::AppState; +use crate::registry; + +/// token 有效期(秒)—— 契约 §6.1:恒为 `7200`。 +const TOKEN_EXPIRES_IN: i64 = 7200; + +/// 登录成功体里的 `tokenTypeName` —— 契约 §6.1:恒为 `"bearer"`。 +const TOKEN_TYPE_NAME: &str = "bearer"; + +/// 登录表单(**form-urlencoded**)。 +/// +/// 🔴 三个字段全是 `Option`:缺字段也要走**业务信封**(`code=400`), +/// 不能落到 axum 默认的 400 文本。 +/// 🔴 `grant_type` 是 **snake_case 字面量**(协议规定),**不能**改成 camelCase。 +/// 🔴 **不派生 `Debug`**:本结构体携带**口令密文**,一次 `{:?}` 就把密文打进日志。 +#[derive(serde::Deserialize)] +pub struct LoginForm { + /// 登录账号。 + pub account: Option, + /// 口令**密文**(hex)。 + pub password: Option, + /// 授权类型(`password`;可缺省)。 + pub grant_type: Option, +} + +/// 登录(契约 §6.1)。 +/// +/// 校验顺序(**不可换**,规格 §6.1 + brief S14): +/// 1. `account` 或 `password` 为空 ⇒ `fail(400, "缺少 account / password")`; +/// 2. `grant_type` **非空**且 ≠ `password` ⇒ `fail(400, "不支持的 grant_type")`; +/// 3. 账号不存在 / 已软删 / 口令不等 / **密文非法** ⇒ `fail(400, "账号或密码错误")`。 +/// +/// 🔴 密文非法(`decrypt_to_md5` 返回 `None`)与「口令错」是**同一条消息** +/// (react 的 `decryptToMd5` 失败返空串 ⇒ 比对不等 ⇒ 同一分支)⇒ 不另造文案。 +/// +/// 🔴 口令比对**大小写不敏感**(两边都转小写再比)。 +/// 🔴 查用户**只比未软删的行**(`f_delete_mark = 0`)。 +pub async fn login(state: &AppState, body: LoginForm) -> Json { + let account = body.account.unwrap_or_default(); + let encrypted = body.password.unwrap_or_default(); + + // ---- 序 1:缺 account / password ---- + if account.is_empty() || encrypted.is_empty() { + return fail(400, "缺少 account / password"); + } + + // ---- 序 2:grant_type 不支持 ---- + // 🔴 `grant_type` **缺失是允许的**;空串按「未设置」处理(与 react 的 falsy 判定一致)。 + if let Some(grant_type) = body.grant_type.as_deref() { + if !grant_type.is_empty() && grant_type != "password" { + return fail(400, "不支持的 grant_type"); + } + } + + // ---- 序 3:查用户(只比未软删的)---- + let rows = match state + .db + .query_json_params( + "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"storedPassword\", \ + f_is_administrator AS \"isAdministrator\" \ + FROM base_user WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", + &[&account], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + // 🔴 契约 §R1.2 / §6.5:DB 报错 ⇒ `系统异常,请联系管理员` + // (**不是**「账号或密码错误」—— DB 挂了不该伪装成口令错: + // 用户会反复重试,运维也看不到告警信号;两条消息必须能区分)。 + // 真因只进服务端日志,**不外泄**。 + eprintln!("[auth] 查询用户失败: {e}"); + return fail(400, "系统异常,请联系管理员"); + } + }; + + let Some(row) = rows.first() else { + // 账号不存在(或已软删)。 + return fail(400, "账号或密码错误"); + }; + + // 库内存的是 `md5(明文)`;密文解出来也是 `md5(明文)` ⇒ 直接比。 + // 🔴 `f_password` 可能是 NULL(官方 DDL 允许)⇒ 视为不匹配。 + // 🔴 JSON 键叫 `storedPassword`(**不叫 `password`**):免得有人一次 + // `println!("{row:?}")` 就把口令哈希打进日志。 + let stored = row.get("storedPassword").and_then(Value::as_str).unwrap_or(""); + let plain_md5 = match decrypt_to_md5(&encrypted) { + Some(md5) => md5, + // 🔴 密文非法(非法 hex / 非法 PKCS7 填充)⇒ **同一条**「账号或密码错误」。 + None => return fail(400, "账号或密码错误"), + }; + if stored.is_empty() || stored.to_lowercase() != plain_md5.to_lowercase() { + return fail(400, "账号或密码错误"); + } + + let user_id = row.get("id").and_then(Value::as_str).unwrap_or("").to_string(); + let account = row + .get("account") + .and_then(Value::as_str) + .unwrap_or(account.as_str()) + .to_string(); + let is_admin = row + .get("isAdministrator") + .and_then(Value::as_i64) + .and_then(|v| i32::try_from(v).ok()) + .unwrap_or(0); + + let token = state.sessions.issue(&account, &user_id, is_admin); + ok(json!({ + "token": token, + "expiresIn": TOKEN_EXPIRES_IN, + "tokenTypeName": TOKEN_TYPE_NAME, + })) +} + +/// 登录端点的**原始 body** 版本(契约 §6.1 的实现注记)。 +/// +/// 🔴 axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` ⇒ `Option>` 编译不过 +/// ⇒ 这里自己用 `serde_urlencoded` 解析。 +/// 🔴 **解析失败也走业务信封**(`fail(400, "缺少 account / password")`), +/// 绝不能让 axum 返默认的 400 文本(前端拿到的是 HTML/纯文本,不是 `{code,msg,data}`)。 +pub async fn login_from_bytes(state: &AppState, body: Bytes) -> Json { + let form = match serde_urlencoded::from_bytes::(&body) { + Ok(form) => form, + Err(_) => return fail(400, "缺少 account / password"), + }; + login(state, form).await +} + +/// axum handler(`POST /api/oauth/Login`)—— Task 10 装配路由时直接用它。 +/// +/// 🔴 比 [`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; + // 🔴 登录成功 ⇒ 把**本次请求的 IP / UA** 补记到刚签发的会话上(在线用户页要显示)。 + // 只在真实 HTTP 路径走这一段:直接调 `login_from_bytes` 的测试没有头可记。 + if resp.0.code == 200 { + if let Some(token) = resp.0.data.get("token").and_then(Value::as_str) { + let ua = headers + .get(axum::http::header::USER_AGENT) + .and_then(|v| v.to_str().ok()) + .unwrap_or(""); + state.sessions.annotate(token, &client_ip(&headers), ua); + } + } + // 🔴 只在**有账号**时记账(连账号都没带 ⇒ 不是一次「登录尝试」,记账只会灌垃圾)。 + 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::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`,最后回环地址。 +pub 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` 解析成同一组枚举)—— +/// 页面这两列只是给人看的,分不出就写「其他」,绝不返空串(空串看起来像数据丢了)。 +pub 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)—— **面 A 形状**。 +/// +/// - 未登录 ⇒ `fail(600, "未登录")`; +/// - 成功 ⇒ `data = {"userInfo": {...}, "menuList": [...]}`。 +/// +/// 🔴 `userName` = **账号**(不是 `realName`);`isAdministrator` 是 **JSON 布尔**。 +/// +/// 🔴 **面 B 分流不在本函数里做** —— 分流点在上层的**装配根**(`routes.rs`): +/// 请求头带 `Vue-Version: 3` ⇒ 走**官方 `PcUserVO` 形状** +/// (`JNPF_COMPAT_SURFACE.md` §3.1);否则走本函数的面 A 形状。 +/// +/// 🔴 **为什么不在这里分流**(M1 解耦的根因):面 B 的形状组装住在契约面 +/// (`compat::helper::current_user`)。若在这里 `if is_face_b { compat::… }`, +/// 平台层就**反向依赖契约面** ⇒ 拆 crate 时是**循环依赖**,编译器直接报错。 +/// 分流点上移到装配根 ⇒ 平台层与契约面**互不知道对方**,壳负责接线。 +/// (与 `CLAUDE.md` §4「共用两条路由按判别头分流」是同一处设计。) +pub async fn current_user(state: &AppState, headers: HeaderMap) -> Json { + let Some(user) = resolve_user(state, &headers) else { + return fail(600, "未登录"); + }; + + // 🔴 多应用:按 `App-Code` 解析当前系统 ⇒ 菜单树与守卫都按该系统隔离。 + let sys = registry::resolve_system(&state.db, registry::app_code_of(&headers).as_deref()).await; + let menu_list = build_menu_list(&state.db, &user.user_id, user.is_admin, &sys.id).await; + + ok(json!({ + "userInfo": { + "userId": user.user_id, + "userAccount": user.account, + "userName": user.account, + "isAdministrator": user.is_admin == 1, + "systemId": sys.id, + "systemCode": sys.code, + }, + "menuList": menu_list, + "currentSystemId": sys.id, + })) +} + +/// 守卫:**未登录** ⇒ `Err(fail(600, "未登录"))`;已登录 ⇒ `Ok(TokenUser)`。 +/// +/// 🔴 失败也是 **HTTP 200** + `code=600`(不是 401)。 +pub async fn require_login( + state: &AppState, + headers: &HeaderMap, +) -> Result> { + match resolve_user(state, headers) { + Some(user) => Ok(user), + None => Err(fail(600, "未登录")), + } +} + +/// 守卫(**面 B**):**未登录 / token 无效** ⇒ `Err(fail(602, …))`;已登录 ⇒ `Ok(TokenUser)`。 +/// +/// 🔴 **面 B 必须返 `602` 而不是 `600`** —— 官方前端 `request.ts:78-80` 只对 +/// `601`/`602`(`TOKEN_ERROR` / `TOKEN_LOGGED` / `TOKEN_TIMEOUT`)清 token +/// ⇒ 只返 `600` 会让页面**卡住不跳登录**(`JNPF_COMPAT_SURFACE.md` §4)。 +/// +/// 🔴 失败也**恒 HTTP 200**(信封里的 `code`),不是 HTTP 401。 +pub async fn require_login_face_b( + state: &AppState, + headers: &HeaderMap, +) -> Result> { + match resolve_user(state, headers) { + Some(user) => Ok(user), + None => Err(fail( + crate::envelope::code::SESSION_ERROR, + "登录状态已失效,请重新登录", + )), + } +} + +/// 守卫(**按面分流**):面 B(`Vue-Version: 3`)⇒ `602`;面 A ⇒ `600`。 +/// +/// 🔴 用在**两个面共用的路由**上(如 `PUT /api/permission/Authority/Data/{objectId}`): +/// 同一个「未登录」场景,**面 A 返 600、面 B 返 602**。 +pub async fn require_login_any( + state: &AppState, + headers: &HeaderMap, +) -> Result> { + // 🔴 同上:判据取契约层,不绕 compat(避免平台层 → 契约面的反向依赖)。 + if sspf_contract::headers::is_face_b(headers) { + require_login_face_b(state, headers).await + } else { + require_login(state, headers).await + } +} + +/// 守卫:**登录 + 菜单权限**。 +/// +/// 1. 先 `require_login`(未登录 ⇒ `600`); +/// 2. 再 `has_module(...)`;无权限 ⇒ `Err(fail(403, "无菜单权限"))`。 +/// +/// 🔴 **多应用**:按 `App-Code` 解析出的当前系统参与菜单守卫 ⇒ 应用间不串。 +/// +/// 🔴 失败也是 **HTTP 200** + `code=403`(不是 403 状态码)。 +pub async fn require_module( + state: &AppState, + headers: &HeaderMap, + module_key: &str, +) -> Result> { + let user = require_login(state, headers).await?; + let system_id = + registry::resolve_system_id(&state.db, registry::app_code_of(headers).as_deref()).await; + if has_module(&state.db, &user.user_id, user.is_admin, module_key, &system_id).await { + Ok(user) + } else { + Err(fail(403, "无菜单权限")) + } +} + +/// 从 `Authorization` 头解析出当前用户(无 / 非法 ⇒ `None`)。 +/// +/// 🔴 `pub` —— 面 B 的 `compat::helper` 也要用它(官方形状的 `CurrentUser`)。 +/// 拆 crate 后 compat 包要跨 crate 调它 ⇒ `pub(crate)` 会失效。 +/// 它**不泄密**:只从 `Authorization` 头取 token,解析失败返 `None`。 +pub fn resolve_user(state: &AppState, headers: &HeaderMap) -> Option { + let auth = headers.get("authorization")?; + let auth = auth.to_str().ok()?; + state.sessions.resolve(Some(auth)) +} diff --git a/crates/sspf-core/src/authorization.rs b/crates/sspf-core/src/authorization.rs new file mode 100644 index 0000000..7eaefbb --- /dev/null +++ b/crates/sspf-core/src/authorization.rs @@ -0,0 +1,467 @@ +//! authorization —— 四源权限合并 + 管理员短路 + 未映射放行 + 菜单树。 +//! +//! 契约:`docs/contract.md` §8.1(四源合并)/ §8.2(判定顺序)/ §8.3(菜单树)。 +//! +//! 🔴 **为什么叫 `authorization` 而不是 `permission`**:本仓的**契约面**按官方模块名 +//! 组织(`compat/permission.rs` = 官方面 B 的 permission 端点集)。平台机制这一层 +//! 要用**语义名**区分开 —— 它管的是「授权判定引擎」,不是「权限端点」。 +//! +//! 逐字对齐 react 参考实现 `ssw-jnpf-lite-react/src/backend/src/sys/permission.service.ts` +//! (`resolveUserModuleIds` / `hasModule` / `buildMenuList` / `toTree`)。 +//! +//! 🔴 **判定顺序不可换**(§8.2): +//! 1. `is_admin == 1` ⇒ 放行(**不查任何 SQL**); +//! 2. 查 `base_module`(`f_url_address = key AND f_delete_mark = 0`) +//! —— **查不到 ⇒ 放行**(未映射放行,对齐 `SswPermissionGuard` 的 warn 路径); +//! 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 +//! +//! 🔴 **DB 报错 ≠「未映射放行」**(契约 §9 的签名没有 `Result` ⇒ 错误只能内部消解, +//! 且消解方向必须是**拒**): +//! - 「查不到」= SQL 执行成功、结果集为空 ⇒ **放行**; +//! - 「查询失败」= DB 报错 ⇒ **拒**(`has_module` 返回 `false`)。 +//! 两条路径必须**分开写** —— 写成 `if !found { return true }` 会把「DB 挂了」变成 +//! 「放行一切」⇒ **全站越权**(且静默)。 +//! +//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` —— 用户标识在 +//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` **才有** +//! `f_user_id`。写错列 ⇒ 授权永远不生效且**静默**。 +//! +//! 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized` 只在 +//! 这一张表上加了 `deleteMark: 0`);`base_role_relation` / `base_user_relation` +//! **不过滤**软删 —— 照抄,不自作主张加过滤。 + +use std::collections::{HashMap, HashSet}; + +use serde::Serialize; + +use crate::db::{pglite, pglite::ToSql, Db}; + +/// 菜单节点(契约 §8.3 的节点形状)。 +/// +/// 🔴 `url_address` / `icon` 为 `None` ⇒ 序列化成 `null`,**键仍在**(不省略)—— +/// 与 TypeORM 的 `nullable: true` 行为一致(内置的 `m_user` / `m_role` / `m_org` / +/// `m_menu` 的 `f_icon` 就是 NULL)。 +/// 🔴 `children` 恒存在(无子节点 ⇒ `[]`)。 +#[derive(Debug, Clone, Serialize)] +pub struct MenuNode { + /// 菜单 id(`base_module.f_id`)。 + pub id: String, + /// 菜单全名(`f_full_name`)。 + #[serde(rename = "fullName")] + pub full_name: String, + /// 前端 Route path(`f_url_address`)—— 可空。 + #[serde(rename = "urlAddress")] + pub url_address: Option, + /// 图标(`f_icon`)—— 可空。 + pub icon: Option, + /// 父菜单 id(`f_parent_id`)—— 空 ⇒ `'0'`。 + #[serde(rename = "parentId")] + pub parent_id: String, + /// 子菜单(按 `f_sort_code` 升序)。 + pub children: Vec, +} + +/// 一行菜单(内部用;`base_module` 的可见列)。 +struct MenuRow { + id: String, + full_name: String, + url_address: Option, + icon: Option, + parent_id: String, +} + +/// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。 +/// +/// 🔴 **这是防御性上限,react 无此概念**(react 的 `toTree` 没有层数概念)—— +/// 契约 §8.3 对层数也无规定。截断只在「菜单嵌套 > 32 层」时生效, +/// 现实中不可达;不封顶则极深的链会让递归爆栈 ⇒ 整个进程死掉。 +const MAX_TREE_DEPTH: usize = 32; + +/// 四源合并(契约 §8.1)—— 用户可见的菜单 id 集合。 +/// +/// 四个来源: +/// 1. **直授**:`base_authorize`(`f_object_type='user'`); +/// 2. **角色**:`base_role_relation`(`f_object_type='user'`)⇒ `f_role_id` +/// ⇒ `base_authorize`(`f_object_type='role'`); +/// 3. **组织**:`base_user_relation`(`f_object_type='organize'`)⇒ `f_object_id` +/// ⇒ `base_authorize`(`f_object_type='organize'`); +/// 4. **岗位**:`base_user_relation`(`f_object_type='position'`)⇒ `f_object_id` +/// ⇒ `base_authorize`(`f_object_type='position'`)。 +/// +/// 🔴 **DB 报错 ⇒ 返回空集**(= 零授权,方向是「拒」),并 `eprintln!` 一行。 +/// 契约 §9 的签名没有 `Result` ⇒ 错误不能往外冒泡(否则会变成裸 HTTP 500)。 +pub async fn resolve_user_module_ids(db: &Db, user_id: &str) -> HashSet { + let mut ids: HashSet = HashSet::new(); + + // ---- 源 1:直授 ---- + if let Err(e) = add_authorized(db, &mut ids, "user", user_id).await { + eprintln!("[permission] 直授授权查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + + // ---- 源 2:角色 ---- + let role_ids = match query_user_role_ids(db, user_id).await { + Ok(ids) => ids, + Err(e) => { + eprintln!("[permission] 用户↔角色关系查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + }; + for role_id in role_ids { + if let Err(e) = add_authorized(db, &mut ids, "role", &role_id).await { + eprintln!("[permission] 角色授权查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + } + + // ---- 源 3:组织 ---- + let organize_ids = match query_user_relation_ids(db, user_id, "organize").await { + Ok(ids) => ids, + Err(e) => { + eprintln!("[permission] 用户↔组织关系查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + }; + for organize_id in organize_ids { + if let Err(e) = add_authorized(db, &mut ids, "organize", &organize_id).await { + eprintln!("[permission] 组织授权查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + } + + // ---- 源 4:岗位 ---- + let position_ids = match query_user_relation_ids(db, user_id, "position").await { + Ok(ids) => ids, + Err(e) => { + eprintln!("[permission] 用户↔岗位关系查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + }; + for position_id in position_ids { + if let Err(e) = add_authorized(db, &mut ids, "position", &position_id).await { + eprintln!("[permission] 岗位授权查询失败(按零授权处理): {e}"); + return HashSet::new(); + } + } + + ids +} + +/// 菜单守卫(契约 §8.2)—— 当前用户能否访问 `module_key` 对应的菜单。 +/// +/// 🔴 判定顺序**不可换**: +/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); +/// 2. 查 `base_module` —— **查不到 ⇒ `true`**(未映射放行); +/// 3. 查得到 ⇒ 菜单 id 是否在四源集合里。 +/// +/// 🔴 **多应用隔离**:`system_id` 把菜单查找限定在「当前应用」(`base_module.f_system_id`) +/// ⇒ 不同应用的同路径菜单互不串(`App-Code` 头路由到哪个应用,就按哪个应用判守卫)。 +/// +/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 +pub async fn has_module( + db: &Db, + user_id: &str, + is_admin: i32, + module_key: &str, + system_id: &str, +) -> bool { + // ---- 1) 管理员短路:在任何 SQL 之前 ---- + if is_admin == 1 { + return true; + } + + // ---- 2) 查菜单 ---- + let module_key = module_key.to_string(); + let rows = match db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_module \ + WHERE f_url_address = $1::text AND f_system_id = $2::text AND f_delete_mark = 0 LIMIT 1", + &[&module_key, &system_id], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + // 🔴 查询失败 ⇒ **拒**(不是「未映射」!) + eprintln!("[permission] 菜单查询失败(按拒绝处理): {e}"); + return false; + } + }; + // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 + let Some(row) = rows.first() else { + return true; + }; + let Some(module_id) = row["id"].as_str() else { + // 主键不该是 NULL;万一如此 ⇒ 保守拒绝。 + eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); + return false; + }; + + // ---- 3) 四源合并集合里有没有它 ---- + // (`resolve_user_module_ids` 出错 ⇒ 空集 ⇒ 这里自然是 `false`。) + resolve_user_module_ids(db, user_id).await.contains(module_id) +} + +/// **面 B 的点权限守卫** —— 当前用户能否访问 `f_en_code = en_code` 的菜单。 +/// +/// 🔴 这是**第二套判据**(面 A 用菜单路径 `f_url_address`;官方用 `f_en_code`), +/// 两者**并存**、互不影响(`JNPF_COMPAT_SURFACE.md` §3.2 / §7 S5)。 +/// 官方形态:`@SaCheckPermission("permission.user")` ⇒ 判「该用户是否持有 +/// `f_en_code='permission.user'` 的菜单授权」。 +/// +/// 🔴 **判定顺序与 [`has_module`] 逐字同构**(不可换): +/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); +/// 2. 查 `base_module`(`f_en_code = $1 AND f_system_id = $2 AND f_delete_mark = 0`) +/// —— **查不到 ⇒ `true`**(未映射放行,与面 A 同一条红线); +/// 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 +/// +/// 🔴 **多应用隔离**:`system_id` 把点权限判据限定在「当前应用」⇒ 不同应用的同 en_code +/// 不会串(官方 `@SaCheckPermission` 也是按当前系统 `currentSystemId` 判)。 +/// +/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 +pub async fn has_en_code_permission( + db: &Db, + user_id: &str, + is_admin: i32, + en_code: &str, + system_id: &str, +) -> bool { + // ---- 1) 管理员短路:在任何 SQL 之前 ---- + if is_admin == 1 { + return true; + } + + // ---- 2) 查菜单(按 `f_en_code`,且限定当前应用)---- + let en_code = en_code.to_string(); + let rows = match db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_module \ + WHERE f_en_code = $1::text AND f_system_id = $2::text AND f_delete_mark = 0 LIMIT 1", + &[&en_code, &system_id], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + eprintln!("[permission] 菜单点权限查询失败(按拒绝处理): {e}"); + return false; + } + }; + // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 + let Some(row) = rows.first() else { + return true; + }; + let Some(module_id) = row["id"].as_str() else { + eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); + return false; + }; + + // ---- 3) 四源合并集合里有没有它 ---- + resolve_user_module_ids(db, user_id).await.contains(module_id) +} + +/// 当前用户可见的菜单树(契约 §8.3)。 +/// +/// - 取 `base_module` 中 `f_delete_mark = 0` 的行,按 `f_sort_code ASC`; +/// - 非管理员:过滤成「id 在四源集合里」的子集; +/// - 建树:`f_parent_id` 为空 / `'0'` / **父不在可见集合内** ⇒ 该节点是根; +/// 否则挂到父节点的 `children`。 +/// +/// 🔴 **DB 报错 ⇒ 返回空 `Vec`**(用户看不到任何入口,方向是「拒」)。 +/// +/// 🔴 **多应用隔离**:`system_id` 把菜单集合限定在「当前应用」(`base_module.f_system_id`) +/// ⇒ 不同应用各看各的菜单(官方 `App-Code` 选应用 ⇒ 菜单树随之切换)。 +pub async fn build_menu_list( + db: &Db, + user_id: &str, + is_admin: i32, + system_id: &str, +) -> Vec { + let rows = match db + .query_json_params( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", \ + f_url_address AS \"urlAddress\", f_icon AS \"icon\", \ + f_parent_id AS \"parentId\" \ + FROM base_module WHERE f_delete_mark = 0 AND f_system_id = $1::text \ + ORDER BY f_sort_code ASC", + &[&system_id], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + eprintln!("[permission] 菜单列表查询失败(按空菜单处理): {e}"); + return Vec::new(); + } + }; + + let mut items: Vec = rows.iter().filter_map(parse_menu_row).collect(); + if is_admin != 1 { + let visible = resolve_user_module_ids(db, user_id).await; + items.retain(|m| visible.contains(&m.id)); + } + build_tree(items) +} + +/// 渲染单个菜单节点(**固定格式**,供菜单树断言逐字比对)。 +/// +/// 格式:`:` + 子节点的 `fullName` 用 `,` 连接 +/// (子节点若有子节点,其后代**不展开** —— 内置菜单最多两层,够用)。 +pub fn render(node: &MenuNode) -> String { + let kids: Vec = node.children.iter().map(|c| c.full_name.clone()).collect(); + format!("{}:{}", node.full_name, kids.join(",")) +} + +/// 渲染整棵菜单树(**固定格式**):根节点的渲染结果用 `|` 连接。 +pub fn render_tree(roots: &[MenuNode]) -> String { + roots.iter().map(render).collect::>().join("|") +} + +// ---- 内部实现 ---- + +/// 把某个对象(用户 / 角色 / 组织 / 岗位)的模块授权并进集合。 +/// +/// 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized`)。 +async fn add_authorized( + db: &Db, + ids: &mut HashSet, + object_type: &str, + object_id: &str, +) -> Result<(), pglite::Error> { + let object_type = object_type.to_string(); + let object_id = object_id.to_string(); + let params: [&(dyn ToSql + Sync); 2] = [&object_type, &object_id]; + let rows = db + .query_json_params( + "SELECT f_item_id AS \"itemId\" FROM base_authorize \ + WHERE f_object_type = $1::text AND f_object_id = $2::text \ + AND f_item_type = 'module' AND f_delete_mark = 0", + ¶ms, + ) + .await?; + for row in rows { + if let Some(item_id) = row["itemId"].as_str() { + if !item_id.is_empty() { + ids.insert(item_id.to_string()); + } + } + } + Ok(()) +} + +/// 用户↔角色关系 ⇒ 角色 id 列表。 +/// +/// 🔴 `base_role_relation` **没有** `f_user_id` —— 用户标识在 `f_object_id` +/// (配 `f_object_type='user'`)。 +/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `roleRelRepo.find`)。 +async fn query_user_role_ids(db: &Db, user_id: &str) -> Result, pglite::Error> { + let user_id = user_id.to_string(); + let params: [&(dyn ToSql + Sync); 1] = [&user_id]; + let rows = db + .query_json_params( + "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ + WHERE f_object_type = 'user' AND f_object_id = $1::text", + ¶ms, + ) + .await?; + Ok(rows + .iter() + .filter_map(|r| r["roleId"].as_str().map(str::to_string)) + .filter(|id| !id.is_empty()) + .collect()) +} + +/// 用户↔组织 / 岗位关系 ⇒ 对象 id 列表。 +/// +/// 🔴 `base_user_relation` **才有** `f_user_id`。 +/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `userRelRepo.find`)。 +async fn query_user_relation_ids( + db: &Db, + user_id: &str, + object_type: &str, +) -> Result, pglite::Error> { + let user_id = user_id.to_string(); + let object_type = object_type.to_string(); + let params: [&(dyn ToSql + Sync); 2] = [&user_id, &object_type]; + let rows = db + .query_json_params( + "SELECT f_object_id AS \"objectId\" FROM base_user_relation \ + WHERE f_user_id = $1::text AND f_object_type = $2::text", + ¶ms, + ) + .await?; + Ok(rows + .iter() + .filter_map(|r| r["objectId"].as_str().map(str::to_string)) + .filter(|id| !id.is_empty()) + .collect()) +} + +/// 一行 JSON ⇒ [`MenuRow`](`f_full_name` / `f_parent_id` 为 NULL ⇒ 取默认值)。 +fn parse_menu_row(row: &serde_json::Value) -> Option { + let id = row["id"].as_str()?.to_string(); + if id.is_empty() { + return None; + } + Some(MenuRow { + id, + full_name: row["fullName"].as_str().unwrap_or_default().to_string(), + url_address: row["urlAddress"].as_str().map(str::to_string), + icon: row["icon"].as_str().map(str::to_string), + // 🔴 react: `parentId: m.parentId || '0'` —— 空 ⇒ `'0'`。 + parent_id: match row["parentId"].as_str() { + Some(p) if !p.is_empty() => p.to_string(), + _ => "0".to_string(), + }, + }) +} + +/// 建树(逐字对齐 react 的 `toTree`)。 +/// +/// 🔴 根的判定:`parentId` 非空 **且** `!== '0'` **且** 父在可见集合内 ⇒ 挂到父节点; +/// 否则(含**父不在集合内**)⇒ **自己就是根**(不是被丢弃)。 +fn build_tree(items: Vec) -> Vec { + let visible: HashSet = items.iter().map(|m| m.id.clone()).collect(); + + let mut by_parent: HashMap> = HashMap::new(); + let mut roots: Vec = Vec::new(); + for item in items { + if item.parent_id != "0" && visible.contains(&item.parent_id) { + by_parent.entry(item.parent_id.clone()).or_default().push(item); + } else { + roots.push(item); + } + } + + roots + .into_iter() + .map(|row| build_node(row, &mut by_parent, 0)) + .collect() +} + +/// 递归建一棵子树。 +fn build_node( + row: MenuRow, + by_parent: &mut HashMap>, + depth: usize, +) -> MenuNode { + // 防御:`f_parent_id` 被改成人为环时不要无限递归(层数封顶 ⇒ 截断)。 + let children = if depth >= MAX_TREE_DEPTH { + Vec::new() + } else { + by_parent + .remove(&row.id) + .unwrap_or_default() + .into_iter() + .map(|child| build_node(child, by_parent, depth + 1)) + .collect() + }; + MenuNode { + id: row.id, + full_name: row.full_name, + url_address: row.url_address, + icon: row.icon, + parent_id: row.parent_id, + children, + } +} diff --git a/crates/sspf-core/src/cipher.rs b/crates/sspf-core/src/cipher.rs new file mode 100644 index 0000000..01ccf43 --- /dev/null +++ b/crates/sspf-core/src/cipher.rs @@ -0,0 +1,213 @@ +//! cipher —— md5 + AES-256-ECB(与 react 版 cipher.ts 逐字节等价)。 +//! +//! 对齐物:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/common/cipher.ts` +//! +//! 契约(**不得改动**,见 `.superpowers/sdd/ssw-jnpf-lite-rust-v1/task-1-brief.md`): +//! 1. `key = md5_hex("EY8WePvjM5GGwQzn")` —— 把这 **32 个 ASCII 字节**当 key ⇒ **AES-256** +//! (⚠️ 不是 16 字节原始摘要;用 16 字节会退化成 AES-128 ⇒ 所有登录全挂) +//! 2. `src = md5_hex(plaintext)` 的 **32 个 ASCII 字节** +//! 3. `AES-256-ECB-PKCS7`,输出 hex(32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符) +//! +//! 🔴 **口令不得外泄**:本模块的输出只在**请求体**里出现(登录时前端传来的密文), +//! 永不在响应里回显。库里存的是 `md5(明文)`(`base_user.f_password`)。 + +use aes::cipher::{ + block_padding::Pkcs7, generic_array::GenericArray, BlockDecryptMut, BlockEncryptMut, KeyInit, +}; +use md5::{Digest, Md5}; + +/// AES-256-ECB 加密器(cipher 0.4 家族:`BlockEncryptMut` + `Pkcs7`)。 +type Aes256EcbEnc = ecb::Encryptor; +/// AES-256-ECB 解密器。 +type Aes256EcbDec = ecb::Decryptor; + +/// react 版 cipher.ts 里的 `CIPHER_KEY`。 +const CIPHER_KEY: &str = "EY8WePvjM5GGwQzn"; + +/// AES 分组长度(字节)。 +const BLOCK_SIZE: usize = 16; + +/// `md5(明文)` 的十六进制串(32 个字符)。 +/// +/// 与 react 版 `md5Hex` 等价:CryptoJS.MD5(str).toString() ⇒ 小写 hex。 +pub fn md5_hex(s: &str) -> String { + hex::encode(Md5::digest(s.as_bytes())) +} + +/// 派生出 AES-256 key:**32 个 ASCII 字节**(即 `md5_hex(CIPHER_KEY)` 这个 32 字符 hex 串本身)。 +fn cipher_key_bytes() -> [u8; 32] { + let key = md5_hex(CIPHER_KEY); + // `md5_hex` 恒为 32 个 ASCII 字符 ⇒ 长度必然是 32。 + let bytes = key.into_bytes(); + let mut out = [0u8; 32]; + out.copy_from_slice(&bytes); + out +} + +/// 登录密码加密:`md5(明文)` → AES-256-ECB-PKCS7 → hex。 +/// +/// 上游检验向量:`encrypt_password("123456")` == +/// `d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b` +/// (96 个 hex 字符 = 48 字节密文;**不是** 64 —— 漏了 PKCS7 填充就会输出 64)。 +pub fn encrypt_password(plain: &str) -> String { + // src = md5(明文) 的 32 个 ASCII 字节。 + let src = md5_hex(plain).into_bytes(); + debug_assert_eq!(src.len(), 32, "md5_hex 恒为 32 个 ASCII 字符"); + + // 32 字节明文 + PKCS7 补满一整块 ⇒ 48 字节密文。 + let mut buf = [0u8; 48]; + buf[..src.len()].copy_from_slice(&src); + + let key_bytes = cipher_key_bytes(); + // 🔴 `KeyInit::new` 是 cipher 0.4 的**不可失败**构造器(`new_from_slice` 内部 + // 就是 `Self::new(Key::from_slice(key))`,两者完全等价)⇒ 去掉 `expect`。 + let key = GenericArray::clone_from_slice(&key_bytes); + let enc = Aes256EcbEnc::new(&key); + let ct = match enc.encrypt_padded_mut::(&mut buf, src.len()) { + Ok(ct) => ct, + Err(_) => { + // 🔴 理论不可达:buf 48 字节、msg 32 字节,PKCS7 最多补 16 字节 ⇒ 放得下。 + // 真到了这里就 **fail closed**(返空串 ⇒ 下游 `decrypt_to_md5` 返 `None` + // ⇒ 登录走「账号或密码错误」),**绝不 panic**(panic 会打断 HTTP 连接)。 + // 🔴 **绝不回显明文/密文**(那是口令泄漏)。 + eprintln!("[cipher] PKCS7 填充失败(理论不可达)"); + return String::new(); + } + }; + hex::encode(ct) +} + +/// 解密前端加密串 → `md5(明文)`,用于登录比对。 +/// +/// 非法 hex / 长度不是分组整数倍 / PKCS7 填充不合法 ⇒ `None`。 +pub fn decrypt_to_md5(encrypted_hex: &str) -> Option { + let mut ct = hex::decode(encrypted_hex).ok()?; + if ct.is_empty() || ct.len() % BLOCK_SIZE != 0 { + return None; + } + + let key = cipher_key_bytes(); + let dec = Aes256EcbDec::new_from_slice(&key).ok()?; + let pt = dec.decrypt_padded_mut::(&mut ct).ok()?; + String::from_utf8(pt.to_vec()).ok() +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 上游(react 版 cipher.ts)检验向量 —— 逐字节相等才算通过。 + #[test] + fn encrypt_password_matches_upstream_vector() { + assert_eq!( + encrypt_password("123456"), + "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" + ); + } + + /// 上游检验向量反向:上游密文解出来必须等于 `md5("123456")`。 + #[test] + fn decrypt_matches_upstream_vector() { + assert_eq!( + decrypt_to_md5( + "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" + ), + Some(md5_hex("123456")) + ); + assert_eq!( + decrypt_to_md5( + "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" + ), + Some("e10adc3949ba59abbe56e057f20f883e".to_string()) + ); + } + + /// 十六进制大小写都接受(前端 CryptoJS `Hex.parse` 产出小写,但别把大小写当契约)。 + #[test] + fn uppercase_hex_input_is_accepted() { + let lower = encrypt_password("123456"); + let upper = lower.to_uppercase(); + assert_ne!(lower, upper, "输入必须真的变成大写,否则这条断言是空转"); + assert_eq!(decrypt_to_md5(&upper), Some(md5_hex("123456"))); + } + + #[test] + fn md5_hex_of_empty_string() { + assert_eq!(md5_hex(""), "d41d8cd98f00b204e9800998ecf8427e"); + } + + #[test] + fn md5_hex_of_abc() { + assert_eq!(md5_hex("abc"), "900150983cd24fb0d6963f7d28e17f72"); + } + + #[test] + fn round_trip_returns_md5_of_plaintext() { + assert_eq!( + decrypt_to_md5(&encrypt_password("hunter2")), + Some(md5_hex("hunter2")) + ); + } + + #[test] + fn invalid_hex_yields_none() { + assert_eq!(decrypt_to_md5("not-hex!!"), None); + assert_eq!(decrypt_to_md5("zz"), None); + } + + /// 32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符。 + #[test] + fn ciphertext_length_is_96_hex_chars() { + assert_eq!(encrypt_password("x").len(), 96); + // 空明文同样走 32 字节 md5,长度不变。 + assert_eq!(encrypt_password("").len(), 96); + } + + /// key 必须是 md5_hex(CIPHER_KEY) 的 **32 个 ASCII 字节** ⇒ AES-256,不是 AES-128。 + #[test] + fn key_is_32_ascii_bytes() { + let key = cipher_key_bytes(); + assert_eq!(key.len(), 32); + assert_eq!(std::str::from_utf8(&key).unwrap(), md5_hex(CIPHER_KEY)); + // 32 字节 key ⇒ AES-256(KeySize = U32)。 + assert!(Aes256EcbEnc::new_from_slice(&key).is_ok()); + } + + /// 长度不是分组整数倍 ⇒ None(解不开)。 + #[test] + fn wrong_length_ciphertext_yields_none() { + assert_eq!(decrypt_to_md5("00"), None); + assert_eq!(decrypt_to_md5(""), None); + } + + /// 规格 §3:**PKCS7 填充不合法 ⇒ `None`**(钉住 `block-padding 0.3.3` 的严格解填充)。 + /// + /// `block-padding-0.3.3/src/lib.rs:216-218` 的 `Pkcs7::raw_unpad` 传 `strict = true` + /// ⇒ 填充字节不全等于长度字节 n 时解填充失败 ⇒ `None`。 + /// + /// 构造(确定性,不靠概率):上游向量是 48 字节密文 = 32 字节明文 + **整块 16 字节填充** + /// ⇒ 最后一个密文块解出来是 16 个 `0x10`。ECB 无扩散 ⇒ 改**密文**的某字节, + /// 只改对应明文字节。 + #[test] + fn invalid_pkcs7_padding_yields_none() { + let good = encrypt_password("123456"); + let bytes = hex::decode(&good).unwrap(); + assert_eq!(bytes.len(), 48, "32 字节明文 + 整块 16 字节填充"); + + // ① 改填充块的**长度字节**(末字节):0x10 → 0x11(= 17 > 块长 16)⇒ 填充非法。 + let mut a = bytes.clone(); + a[47] ^= 0x01; + let corrupted_len_byte = hex::encode(&a); + assert_ne!(corrupted_len_byte, good); + assert_eq!(decrypt_to_md5(&corrupted_len_byte), None); + + // ② 改填充块**中间某个填充字节**(第 2 个):0x10 → 0x0f。 + // 长度字节仍是 0x10(= 16,合法范围),但填充字节不自洽 + // ⇒ **严格模式**才拒;宽松模式会照单全收 ⇒ 这条断言正是「严格性」的证据。 + let mut b = bytes.clone(); + b[32 + 1] = 0x0f; + let corrupted_fill_byte = hex::encode(&b); + assert_ne!(corrupted_fill_byte, good); + assert_eq!(decrypt_to_md5(&corrupted_fill_byte), None); + } +} diff --git a/crates/sspf-core/src/config.rs b/crates/sspf-core/src/config.rs new file mode 100644 index 0000000..381c524 --- /dev/null +++ b/crates/sspf-core/src/config.rs @@ -0,0 +1,15 @@ +//! config —— 环境变量与路径解析(**转发到 [`sspf_store::config`]**)。 +//! +//! 🔴 真值源在 `crates/sspf-store/src/config.rs`(存储层)。 +//! 本文件只做转发,保持 `crate::config::*` 这个既有路径可用。 +//! +//! 契约:`docs/contract.md` §9「config.rs」。 +//! +//! 路径口径: +//! - `project_dir` = 项目根(由 `main.rs` 从可执行文件向上定位锚点文件得到)。 +//! - `data_dir` = `PGLITE_DIR`,缺省 `/src/backend/data/lite.pg`。 +//! +//! 🔴 `Profile`(部署档位)也定义在 config 里 —— 它是**配置**,不是安全判定; +//! 放 guard 里会造成 `config → guard → db` 的假依赖。 + +pub use sspf_store::config::*; diff --git a/crates/sspf-core/src/crud.rs b/crates/sspf-core/src/crud.rs new file mode 100644 index 0000000..90e8cf0 --- /dev/null +++ b/crates/sspf-core/src/crud.rs @@ -0,0 +1,931 @@ +//! crud —— spec 驱动的通用 CRUD 引擎(**平台层**:不含任何业务 spec / 表名 / app_code)。 +//! +//! 🔴 **业务侧([`crate::modules`])把 [`EntitySpec`](crate::entity::EntitySpec) +//! 声明进来,本引擎负责把 spec 变成 SQL**——加一张新业务表**不用改本文件**。 +//! +//! 契约:`docs/contract.md` §5.3(投影列集)+ §6.4(端点)+ §7.6(业务模块语义) +//! 与 §9(`crud.rs` 接口)。 +//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/{demo,shop,books}/` +//! 里的 `*.service.ts`(**逐条对齐**)。 +//! +//! 🔴 **七条硬约定**: +//! 1. **业务失败恒 HTTP 200**(信封里的 `code`);DB 报错 ⇒ `系统异常,请联系管理员` +//! (真因只进服务端日志,**不外泄**)。 +//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 +//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `price` 之外的大小写形态 ⇒ 前端读不到, +//! 且**静默**)。 +//! 3. **numeric 列必须投影成字符串**(`f_price::text AS "price"` ⇒ `"9.90"`); +//! `int` 列保持数字(`f_stock` ⇒ `100`)。 +//! 4. **标识符白名单 + 参数化**:表名 / 列名先过 `db::valid_table` / `db::valid_column`; +//! **所有值**走绑定参数,绝不拼进 SQL 文本。 +//! 5. **不用 axum 的 `Json` / `Query`**(前者 422、后者 400 ⇒ 非信封 body ⇒ 契约破) +//! ⇒ 取 `Bytes` / `RawQuery` 自己解析。 +//! 6. **只写 body 里出现的键**(react 的 `Object.assign` / TypeORM 的 `undefined` 语义)。 +//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 +//! +//! 🔴 **Save 的三条路径(顺序不可换,裁决 S20 / S21 / S22)**: +//! | 路径 | 条件 | 写入内容 | +//! |---|---|---| +//! | 1 | body 里**无 id** | 新 uuid + now + `f_delete_mark=0` + spec 的 `default` | +//! | 2 | body 有 id、**库里查不到** | **只用该 id 新建**;body 没给的列**不写** | +//! | 3 | body 有 id、**库里查得到** | 覆盖更新(只覆盖 body 里出现的列) | +//! +//! 🔴 **路径 1 与路径 2 的默认值完全不同**:路径 1 用 spec 的 `default`(`'草稿'` / `'0.00'`), +//! 路径 2 **一个默认值都不加**(`f_stock` / `f_delete_mark` 由 DDL 的 `DEFAULT 0` 补出)。 +//! +//! 🔴 **空 body 的处理是「有意偏离」**:**0 字节 body** ⇒ JSON 解析失败 ⇒ +//! `请求参数格式错误`(HTTP 200 + 信封);而 JSON 数组 / 数字 / 字符串被当作**空对象** ⇒ 走路径 1 建行。 +//! react 侧 express body-parser 对空 body 给 `{}` ⇒ 建行 —— 本仓**有意不跟随**, +//! 依据是契约的通用规则「非法 JSON ⇒ 请求参数格式错误」;契约未覆盖 0 字节 body。 + +use axum::body::Bytes; +use axum::extract::{RawQuery, State}; +use axum::http::HeaderMap; +use axum::routing::{delete, get, post}; +use axum::{Json, Router}; +use serde_json::{Map, Value}; + +use crate::auth::{require_login, require_login_face_b, require_module}; +use crate::db::{self, pglite, pglite::ToSql, Db}; +use crate::envelope::{code, fail, ok, ActionResult}; +use crate::entity::{ColumnSpec, EntitySpec}; +use crate::ids::new_uuid; +use crate::authorization::has_en_code_permission; +use crate::route::{HttpMethod, PackRoute, RouteAction, RouteGuard}; +use crate::session::TokenUser; +use crate::state::AppState; +use crate::registry; + +/// `f_creator_user_id` 的兜底账号(**账号字符串,不是 uuid**)。 +/// +/// 🔴 `seed.rs` 里也有个同值常量,但那是**私有**的 ⇒ 这里定义自己的(裁决 S18)。 +const ADMIN_ACCOUNT: &str = "admin"; + +// 🔴 **平台层不认 app_code**:哪张表用「`f_creator_user_id` 写死」这条规则,是**业务知识** +// ⇒ 由业务 spec 的 `creator_fixed` 声明(`crate::modules::demo` 声明 `Some("admin")`), +// 引擎只读声明 ⇒ 加新业务表**不用改本文件**(裁决 S22)。 + +// ---------------------------------------------------------------- 通用小工具 + +/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 +fn db_error(e: pglite::Error, ctx: &str) -> Json { + eprintln!("[crud] {ctx}失败: {e}"); + fail(400, "系统异常,请联系管理员") +} + +/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 +fn now_str() -> String { + chrono::Utc::now() + .naive_utc() + .format("%Y-%m-%d %H:%M:%S") + .to_string() +} + +/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 +/// +/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 +fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { + values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() +} + +/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 +pub fn value_to_text(v: Option<&Value>) -> Option { + match v { + Some(Value::String(s)) => Some(s.clone()), + Some(Value::Number(n)) => Some(n.to_string()), + Some(Value::Bool(b)) => Some(b.to_string()), + _ => None, + } +} + +/// body 值 ⇒ 文本,但**按 JS 真值判定**(`||` 语义): +/// 空串 / `null` / 数字 `0` / `false` ⇒ `None`(falsy);其余 ⇒ 文本。 +/// +/// 🔴 用于 `body.creatorUserId || 'admin'`(react 的写法)—— 注意它与 +/// `??`([`value_to_text`] + 显式 null 回落)**不是一回事**。 +fn js_truthy_text(v: Option<&Value>) -> Option { + match v { + Some(Value::String(s)) if s.is_empty() => None, + Some(Value::String(s)) => Some(s.clone()), + Some(Value::Number(n)) => { + if n.as_f64().map(|f| f == 0.0).unwrap_or(false) { + None + } else { + Some(n.to_string()) + } + } + Some(Value::Bool(true)) => Some("true".to_string()), + _ => None, + } +} + +/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 +/// +/// 🔴 与 `sys.rs::body_id` **完全一致**(裁决 S20): +/// - 键不存在 / `null` / 空串 ⇒ **无 id**(路径 1); +/// - 非空字符串 ⇒ **有 id**; +/// - 其它类型(数字 / 布尔)⇒ **有 id**(按其 JSON 文本去查)。 +fn body_id(obj: &Map) -> Option { + match obj.get("id") { + None | Some(Value::Null) => None, + Some(Value::String(s)) if s.is_empty() => None, + Some(Value::String(s)) => Some(s.clone()), + Some(other) => Some(other.to_string()), + } +} + +/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 +/// +/// 🔴 **不用 axum 的 `Query`**:解析失败会返回 400 + 非信封 body ⇒ 契约破。 +fn query_param(raw: &RawQuery, key: &str) -> String { + let Some(q) = raw.0.as_deref() else { + return String::new(); + }; + let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); + pairs + .into_iter() + .find(|(k, _)| k == key) + .map(|(_, v)| v) + .unwrap_or_default() +} + +/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 +fn parse_body(body: &Bytes) -> Result, Json> { + match serde_json::from_slice::(body) { + Ok(Value::Object(m)) => Ok(m), + // 🔴 **不是对象**(数组 / 数字 / 字符串)⇒ 当作空对象(⇒ 走「参数缺失」分支)。 + Ok(_) => Ok(Map::new()), + Err(_) => Err(fail(400, "请求参数格式错误")), + } +} + +// ---------------------------------------------------------------- spec → SQL + +/// spec 的一列的 JSON 键(**校验它与契约的映射一致**)。 +/// +/// 🔴 `json_key` 写错 ⇒ 投影别名与 body 键**同时**对不上 ⇒ 前端读不到字段,且**静默**。 +fn json_key_of(col: &ColumnSpec) -> Result { + let expect = db::column_to_json_key(col.column); + if expect != col.json_key { + return Err(pglite::Error::Protocol(format!( + "spec 的 json_key 不对: {} 应为 {}(实际 {})", + col.column, expect, col.json_key + ))); + } + Ok(col.json_key.to_string()) +} + +/// 写入口的类型转换后缀(追加在 `::text` 之后)。 +/// +/// 🔴 **规律优于枚举**:任何 `f_*_time` 列都是 `TIMESTAMP`(项目 DDL 约定)⇒ +/// 业务表自带的时间列(如 `f_register_time`)**不用**再往这里加一条 —— +/// 否则「加一个业务模块要改平台层」就被这条类型转换破坏了。 +fn write_cast(column: &str) -> &'static str { + if column.ends_with("_time") { + return "::timestamp"; + } + match column { + "f_price" => "::numeric", + "f_stock" => "::integer", + "f_delete_mark" => "::integer", + _ => "", + } +} + +/// 构造读回投影(`f_xxx AS ""`,**每列都带双引号**)。 +fn projection(spec: &EntitySpec) -> Result { + let mut parts: Vec = Vec::with_capacity(spec.columns.len()); + for col in spec.columns { + let name = db::valid_column(col.column).ok_or_else(|| { + pglite::Error::Protocol(format!("非法列名: {}", col.column)) + })?; + let key = json_key_of(col)?; + parts.push(match col.column { + // 🔴 时间列:NULL 时 `to_char(NULL,…) || 'Z'` ⇒ **NULL**(PG 语义),不是 `"Z"`。 + "f_creator_time" => format!( + "to_char({name}, 'YYYY-MM-DD\"T\"HH24:MI:SS') || 'Z' AS \"{key}\"" + ), + // 🔴 numeric 列必须 `::text` ⇒ JSON 是**字符串**(`"9.90"`)。 + _ if col.numeric => format!("{name}::text AS \"{key}\""), + _ => format!("{name} AS \"{key}\""), + }); + } + Ok(parts.join(", ")) +} + +/// 表名过白名单。 +fn table_of(spec: &EntitySpec) -> Result { + db::valid_table(spec.table) + .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {}", spec.table))) +} + +// ---------------------------------------------------------------- 引擎 + +/// 列出未软删的行(契约 §7.6):`f_delete_mark = 0`,按 `f_creator_time DESC`。 +pub async fn list(db: &Db, spec: &EntitySpec) -> Result, pglite::Error> { + let table = table_of(spec)?; + let proj = projection(spec)?; + let sql = format!( + "SELECT {proj} FROM {table} WHERE f_delete_mark = 0 ORDER BY f_creator_time DESC" + ); + db.query_json(&sql).await +} + +/// 新建 / 更新一行(契约 §7.6 的三条路径)⇒ 返回**落库后重新读回**的那一行。 +pub async fn save(db: &Db, spec: &EntitySpec, body: &Value) -> Result { + let table = table_of(spec)?; + let obj: Map = match body { + Value::Object(m) => m.clone(), + _ => Map::new(), + }; + + let id = match body_id(&obj) { + // ---- 路径 1:无 id ⇒ 新建 ---- + None => { + let new_id = insert_new(db, spec, &table, &obj, None).await?; + new_id + } + // ---- 有 id:查库 ⇒ 路径 2(查不到 ⇒ 用该 id 新建)/ 路径 3(查到 ⇒ 覆盖)---- + Some(given_id) => { + if row_exists(db, &table, &given_id).await? { + update_existing(db, spec, &table, &given_id, &obj).await?; + given_id + } else { + insert_new(db, spec, &table, &obj, Some(given_id)).await? + } + } + }; + + // ---- 响应体 = 落库后重新读回的那一行 ---- + fetch_by_id(db, &table, spec, &id) + .await? + .ok_or_else(|| pglite::Error::Protocol(format!("写入后读不回该行: {id}"))) +} + +/// 软删一行(`f_delete_mark = 1`)—— **不检查是否存在** ⇒ 幂等。 +pub async fn remove(db: &Db, spec: &EntitySpec, id: &str) -> Result<(), pglite::Error> { + let table = table_of(spec)?; + // 🔴 一条 UPDATE ⇒ 天然原子(裁决 S16)。 + let sql = format!("UPDATE {table} SET f_delete_mark = 1 WHERE f_id = $1::text"); + db.exec_params(&sql, &[&id]).await +} + +/// 该 id 的行是否存在(**不过滤 `f_delete_mark`** —— 与 react 的 `findOne({where:{id}})` 一致)。 +async fn row_exists(db: &Db, table: &str, id: &str) -> Result { + let sql = format!("SELECT f_id AS \"id\" FROM {table} WHERE f_id = $1::text LIMIT 1"); + let rows = db.query_json_params(&sql, &[&id]).await?; + Ok(!rows.is_empty()) +} + +/// 按 id 读回一行(`None` ⇒ 没有这行)。 +async fn fetch_by_id( + db: &Db, + table: &str, + spec: &EntitySpec, + id: &str, +) -> Result, pglite::Error> { + let proj = projection(spec)?; + let sql = format!("SELECT {proj} FROM {table} WHERE f_id = $1::text LIMIT 1"); + let rows = db.query_json_params(&sql, &[&id]).await?; + Ok(rows.into_iter().next()) +} + +/// 插入一行。 +/// +/// - `forced_id = None` ⇒ **路径 1**:新 uuid + now + `f_delete_mark=0` + spec 的 `default`; +/// - `forced_id = Some(id)` ⇒ **路径 2**:用该 id 新建,**body 没给的列一律不写** +/// (⇒ 走 DDL 的 `DEFAULT` / `NULL`;裁决 S21)。 +/// +/// 🔴 **路径 1 与路径 2 的默认值规则完全不同**,别混用。 +async fn insert_new( + db: &Db, + spec: &EntitySpec, + table: &str, + obj: &Map, + forced_id: Option, +) -> Result { + let mut cols: Vec = Vec::with_capacity(spec.columns.len()); + let mut values: Vec> = Vec::with_capacity(spec.columns.len()); + let mut row_id = String::new(); + + for col in spec.columns { + let name = db::valid_column(col.column).ok_or_else(|| { + pglite::Error::Protocol(format!("非法列名: {}", col.column)) + })?; + + // ---- 主键 ---- + if col.column == "f_id" { + row_id = forced_id.clone().unwrap_or_else(new_uuid); + cols.push(name); + values.push(Some(row_id.clone())); + continue; + } + + // ---- 路径 2:body 没给 ⇒ **不写这一列** ---- + // (⇒ `f_creator_time` ⇒ NULL、`f_status`/`f_price` ⇒ NULL、 + // `f_stock`/`f_delete_mark` ⇒ DDL 的 `DEFAULT 0`) + if forced_id.is_some() { + let Some(v) = obj.get(col.json_key) else { + continue; + }; + cols.push(name); + values.push(value_to_text(Some(v))); + continue; + } + + // ---- 路径 1 ---- + let value: Option = match col.column { + "f_creator_time" => Some(now_str()), + // 🔴 路径 1 的 `f_delete_mark` 恒为 0(react 的 `deleteMark: 0` 写死)。 + "f_delete_mark" => Some("0".to_string()), + // 🔴 `f_creator_user_id` 三张表规则不同(裁决 S22): + // demo ⇒ 硬编码 `'admin'`;其余 ⇒ `body.creatorUserId || 'admin'`。 + // 🔴 走哪条由**业务 spec 的 `creator_fixed`** 决定(平台层不认 app_code)。 + "f_creator_user_id" => match spec.creator_fixed { + Some(fixed) => Some(fixed.to_string()), + None => { + // 🔴 JS `||` 语义(空串 / 数字 0 ⇒ 回落 `'admin'`)。 + match js_truthy_text(obj.get(col.json_key)) { + Some(s) => Some(s), + None => Some(ADMIN_ACCOUNT.to_string()), + } + } + }, + // 其余:body 给了就用;没给 ⇒ spec 的 default;再没有 ⇒ NULL。 + // 🔴 JS `??` 语义(react 的 `item.status ?? '草稿'`):**显式 null 也回落默认值**。 + _ => match obj.get(col.json_key) { + Some(Value::Null) | None => col.default.map(str::to_string), + Some(v) => value_to_text(Some(v)), + }, + }; + cols.push(name); + values.push(value); + } + + if cols.is_empty() { + return Err(pglite::Error::Protocol("没有可写入的列".to_string())); + } + + let placeholders: Vec = (1..=values.len()) + .map(|i| format!("${i}::text{}", write_cast(&cols[i - 1]))) + .collect(); + let sql = format!( + "INSERT INTO {table} ({}) VALUES ({})", + cols.join(", "), + placeholders.join(", ") + ); + db.exec_params(&sql, ¶ms_of(&values)).await?; + Ok(row_id) +} + +/// 覆盖更新一行(路径 3):**只覆盖 body 里出现的该实体已知列**(`Object.assign` 语义)。 +async fn update_existing( + db: &Db, + spec: &EntitySpec, + table: &str, + id: &str, + obj: &Map, +) -> Result<(), pglite::Error> { + let mut assigns: Vec = Vec::new(); + let mut values: Vec> = Vec::new(); + + for col in spec.columns { + // 🔴 主键不参与更新。 + if col.column == "f_id" { + continue; + } + let Some(name) = db::valid_column(col.column) else { + continue; + }; + // 🔴 body 里没有这个键 ⇒ **不动原值**。 + let Some(v) = obj.get(col.json_key) else { + continue; + }; + values.push(value_to_text(Some(v))); + // 🔴 与 `insert_new` 同一写法:值一律按 text 传 ⇒ `$n::text` **必须**带上, + // 否则 PG 会把参数**推断成**目标列类型(`::timestamp` / `::numeric` / `::integer`) + // ⇒ pglite 拿 `Option` 去绑一个 timestamp 参数 ⇒ 直接报 + // `cannot convert between the Rust type ... and the Postgres type timestamp`。 + assigns.push(format!( + "{name} = ${}::text{}", + values.len(), + write_cast(col.column) + )); + } + + // body 里没有任何已知列 ⇒ 什么都不改(react 的 `Object.assign(existing, {})`)。 + if assigns.is_empty() { + return Ok(()); + } + + values.push(Some(id.to_string())); + let sql = format!( + "UPDATE {table} SET {} WHERE f_id = ${}::text", + assigns.join(", "), + values.len() + ); + db.exec_params(&sql, ¶ms_of(&values)).await +} + +// ---------------------------------------------------------------- 守卫 + handler + +/// 按 spec 的 `module_key` 做守卫: +/// - `None` ⇒ **仅登录**; +/// - `Some(k)` ⇒ 登录 + 菜单权限(`require_module` 内含登录判定,**不要**再叠 `require_login`)。 +async fn guard( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, +) -> Result> { + match spec.module_key { + None => require_login(state, headers).await, + Some(key) => require_module(state, headers, key).await, + } +} + +// ---------------------------------------------------------------- 面 B 守卫(业务包路由) +// +// 🔴 **为什么业务包路由要用另一套守卫**(批次 12 交付物 ① 的第 2 条修正): +// 业务包声明的路由是**面 B**(官方 JNPF 形状)⇒ **官方前端会直接调它** +// ⇒ 它的守卫**必须**是面 B 的判据,**不是**面 A 的: +// +// | | 面 A(`/api/ssw/...`) | 面 B(`/api/{模块}/{资源}`) | +// |---|---|---| +// | 判据 | 菜单路径 `f_url_address` | 点权限 `f_en_code` | +// | 官方对应 | `SswPermissionGuard.requireMenu(...)` | `@SaCheckPermission("xxx.yyy")` | +// | 未登录码 | **600** | **602**(官方前端只在 601/602 清 token) | +// +// 🔴 **602 这条是硬要求**(`MIGRATION.md` §2.5):官方前端 +// `request.ts:78-80` 只对 `601`/`602` 清 token ⇒ 只返 600 会让页面**卡住不跳登录**。 +// ⇒ 面 A 保持 600、面 B 返 602 —— **两套并存**(与判据一样并存)。 + +/// 面 B 的守卫:**登录(602)** + **点权限(`f_en_code` ⇒ 403)**。 +/// +/// 🔴 与 [`face_b`] 模块里的同名函数**同义**(逐字同构)—— 官方 +/// `@SaCheckPermission("xxx")` 的判据就是 `base_module.f_en_code`。 +async fn guard_face_b( + state: &AppState, + headers: &HeaderMap, + en_code: &str, +) -> Result> { + let user = require_login_face_b(state, headers).await?; + let system_id = + registry::resolve_system_id(&state.db, registry::app_code_of(headers).as_deref()).await; + if has_en_code_permission(&state.db, &user.user_id, user.is_admin, en_code, &system_id).await { + Ok(user) + } else { + Err(fail(code::NO_PERMISSION, "无权限")) + } +} + +/// 业务包路由的守卫(按声明的 [`RouteGuard`] 分派)。 +async fn guard_pack( + state: &AppState, + headers: &HeaderMap, + guard: RouteGuard, +) -> Result> { + match guard { + RouteGuard::Login => require_login_face_b(state, headers).await, + RouteGuard::EnCode(en_code) => guard_face_b(state, headers, en_code).await, + } +} + +/// List 的通用实现。 +pub async fn handle_list( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, +) -> Json { + if let Err(resp) = guard(state, headers, spec).await { + return resp; + } + match list(&state.db, spec).await { + Ok(rows) => ok(Value::Array(rows)), + Err(e) => db_error(e, "业务列表查询"), + } +} + +/// Save 的通用实现。 +pub async fn handle_save( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, + body: &Bytes, +) -> Json { + if let Err(resp) = guard(state, headers, spec).await { + return resp; + } + let obj = match parse_body(body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let value = Value::Object(obj); + match save(&state.db, spec, &value).await { + Ok(row) => ok(row), + Err(e) => db_error(e, "业务保存"), + } +} + +/// Delete 的通用实现(**不检查是否存在** ⇒ 幂等)。 +pub async fn handle_delete( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, + raw: &RawQuery, +) -> Json { + if let Err(resp) = guard(state, headers, spec).await { + return resp; + } + let id = query_param(raw, "id"); + match remove(&state.db, spec, &id).await { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "业务删除"), + } +} + +// ---------------------------------------------------------------- 面 B 的业务包 handler +// +// 🔴 **为什么业务包路由的响应形状与面 A 不同**: +// 官方 `ActionResult.page(list, pagination)` ⇒ `data` 是 **`PageListVO`** +// (`{pagination:{currentPage,pageSize,total}, list:[…]}`), +// **不是**裸数组(面 A 才是裸数组)。 +// ⇒ 官方前端拿到裸数组 ⇒ 读 `res.data.list` 是 `undefined` ⇒ **静默**空表格。 +// ⇒ 这就是「官方前端能直连本仓」的那条承诺里最容易被忽略的一格。 +// +// 🔴 **分页参数**:官方 `Pagination.java` 默认 `currentPage=1` / `pageSize=20`, +// 夹逼 `[1, 1000]`(与 [`face_b::Paging`] 同口径)。 + +/// 取分页参数(官方 `Pagination` 默认值 + 夹逼)。 +struct PackPaging { + current_page: i64, + page_size: i64, + offset: i64, +} + +impl PackPaging { + fn of(raw: &RawQuery) -> Self { + let current_page = crate::sys::query_param(raw, "currentPage") + .trim() + .parse::() + .unwrap_or(1) + .max(1); + let page_size = crate::sys::query_param(raw, "pageSize") + .trim() + .parse::() + .unwrap_or(20) + .clamp(1, 1000); + Self { + current_page, + page_size, + offset: (current_page - 1) * page_size, + } + } +} + +/// 官方 `PageListVO` —— `{pagination:{currentPage,pageSize,total}, list:[…]}`。 +fn pack_page_list(current_page: i64, page_size: i64, total: i64, list: Vec) -> Value { + serde_json::json!({ + "pagination": { + "currentPage": current_page, + "pageSize": page_size, + "total": total, + }, + "list": list, + }) +} + +/// 面 B 的列表(分页 + `PageListVO` 形状)。 +pub async fn handle_list_face_b( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, + guard: RouteGuard, + raw: &RawQuery, +) -> Json { + if let Err(resp) = guard_pack(state, headers, guard).await { + return resp; + } + let page = PackPaging::of(raw); + let table = match db::valid_table(spec.table) { + Some(t) => t, + None => return fail(400, "系统异常,请联系管理员"), + }; + let proj = match projection(spec) { + Ok(p) => p, + Err(_) => return fail(400, "系统异常,请联系管理员"), + }; + // 🔴 **总数与列表两条 SQL**(官方 `IPage` 的等价做法)。 + let total_sql = format!("SELECT count(*)::bigint AS \"c\" FROM {table} WHERE f_delete_mark = 0"); + let total = match state.db.query_json(&total_sql).await { + Ok(rows) => rows + .into_iter() + .next() + .and_then(|r| r["c"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "业务列表计数"), + }; + let list_sql = format!( + "SELECT {proj} FROM {table} WHERE f_delete_mark = 0 \ + ORDER BY f_creator_time DESC LIMIT {page_size} OFFSET {page_offset}", + page_size = page.page_size, + page_offset = page.offset, + ); + let rows = match state.db.query_json(&list_sql).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "业务列表查询"), + }; + ok(pack_page_list( + page.current_page, + page.page_size, + total, + rows, + )) +} + +/// 面 B 的新建 / 更新(响应 = 落库后读回的那一行,与面 A 同形)。 +pub async fn handle_save_face_b( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, + guard: RouteGuard, + body: &Bytes, +) -> Json { + if let Err(resp) = guard_pack(state, headers, guard).await { + return resp; + } + let obj = match parse_body(body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let value = Value::Object(obj); + match save(&state.db, spec, &value).await { + Ok(row) => ok(row), + Err(e) => db_error(e, "业务保存"), + } +} + +/// 面 B 的软删(`{id}` 走路径参数)。 +pub async fn handle_delete_face_b( + state: &AppState, + headers: &HeaderMap, + spec: &EntitySpec, + guard: RouteGuard, + id: &str, +) -> Json { + if let Err(resp) = guard_pack(state, headers, guard).await { + return resp; + } + match remove(&state.db, spec, id).await { + Ok(()) => ok(Value::Null), + Err(e) => db_error(e, "业务删除"), + } +} + +// ---------------------------------------------------------------- spec 取值(编译期常量) +// +// 🔴 **平台层不持有任何业务 spec** —— spec 全在 [`crate::modules`](demo / shop / books)。 +// 引擎只认传入的 `&EntitySpec` ⇒ 加一张新业务表**不用改本文件**。 + +// ---------------------------------------------------------------- 路由生成(spec 驱动) +// +// 🔴 **这是「业务包自带路由、平台层零改动」的落点**(批次 12 交付物 ①): +// 业务包声明 [`PackRoute`](纯数据:路径 + 方法 + 实体名), +// 本函数按声明**生成真正的 axum 路由** —— 引擎认识 spec ⇒ 直接复用。 +// ⇒ 业务包**不需要**依赖 axum(AR2/AR8 钉死),内核**不需要**知道任何业务路径。 + +/// 按业务包声明的路由生成 axum 路由(`Router::merge` 进总路由)。 +/// +/// 🔴 **入参是 `&[&'static PackRoute]`** —— 路由声明是编译期常量, +/// 这里只读不写。 +/// +/// 🔴 **动作与方法的对应关系被钉死**(不许自由组合): +/// | action | 允许的 method | 语义 | id 来源 | +/// |---|---|---|---| +/// | `List` | GET | 查列表(分页 + `PageListVO`) | — | +/// | `Save` | POST | 新建 / 更新 | body 的 `id` | +/// | `Delete` | DELETE | 软删 | **路径参数 `{id}`** | +/// +/// 🔴 **Delete 的 id 走路径参数**(官方 RESTful:`DELETE /api/{模块}/{资源}/{id}`) +/// ⇒ 路径里**必须**含 `{id}` ⇒ 不含就不生成这条路由(宁可少一条,也不要一条 +/// 永远收不到 id 的路由 —— 那种路由会静默删掉空 id 的行)。 +/// +/// 不在表里的组合 ⇒ **不生成路由**(而不是生成一个恒 400 的空实现)。 +/// 理由:官方 JNPF 有一批非 CRUD 端点(`/AsyncList/{id}` / `/Actions/ResetPassword`), +/// 它们由面 B 的专用 handler 实现,**不归业务包管**。 +/// +/// 🔴 **返回值类型是 `Router`** —— 与 `modules::router()` 一致, +/// 内核只需 `.merge(...)` 一次。 +pub fn crud_router(spec: &'static EntitySpec, routes: &[&'static PackRoute]) -> Router { + let mut router = Router::new(); + for r in routes { + // 🔴 路由的 entity 必须与 spec 对得上(装载器已校验过,这里是二道闸)。 + if r.entity != spec.entity { + continue; + } + // 🔴 **先把要捕获的值拷出来**(`Copy` 类型)—— + // 直接在闭包里写 `r.guard` 会把 `r`(指向入参切片,生命周期 `'1`) + // 一起捕获 ⇒ 编译报「borrowed data escapes outside of function」。 + let path = r.path; + let guard = r.guard; + match (r.action, r.method) { + (RouteAction::List, HttpMethod::Get) => { + router = router.route( + path, + get( + move |State(state): State, + headers: HeaderMap, + raw: RawQuery| async move { + handle_list_face_b(&state, &headers, spec, guard, &raw).await + }, + ), + ); + } + (RouteAction::Save, HttpMethod::Post) => { + router = router.route( + path, + post( + move |State(state): State, + headers: HeaderMap, + body: Bytes| async move { + handle_save_face_b(&state, &headers, spec, guard, &body).await + }, + ), + ); + } + (RouteAction::Delete, HttpMethod::Delete) => { + // 🔴 路径必须带 `{id}` —— 官方 RESTful 的删除是 `DELETE /api/{模块}/{资源}/{id}`。 + if !path.contains("{id}") { + continue; + } + router = router.route( + path, + delete( + move |State(state): State, + headers: HeaderMap, + axum::extract::Path(id): axum::extract::Path| async move { + handle_delete_face_b(&state, &headers, spec, guard, &id).await + }, + ), + ); + } + // 🔴 不在表里的组合 ⇒ **不生成路由**(静默跳过 = 少一条路由 = 404, + // 而不是 400 ⇒ 前端能区分「端点不存在」与「业务拒绝」)。 + _ => {} + } + } + router +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 🔴 **合成的 spec**(`core` crate 的单元测试**不许依赖业务层** —— + /// `crate::modules` 住在壳里,而壳依赖 core ⇒ core 依赖壳 = 循环依赖)。 + /// + /// 这三个 spec **刻意覆盖引擎的每条分支**: + /// - `SYNTH_SPEC`:普通列 + numeric 列 + 时间列(投影的三种形状); + /// - `SYNTH_SPEC_MIN`:最小列集(`f_id` 一个列)。 + /// + /// 🔴 **为什么合成 spec 够用**:引擎对 spec 的依赖只有三处 —— + /// `json_key_of`(走契约层的列名映射)、`write_cast`(按**列名后缀**判类型)、 + /// `projection`(按 `col.numeric` 与列名判形状)。三者都是**纯函数**, + /// 与业务无关 ⇒ 合成 spec 能覆盖它们的全部分支。 + /// 🔴 **真正的业务 spec 另有测试**(壳层 `tests/crud_it.rs` 跑真实 spec 的读写)。 + const SYNTH_COLUMNS: &[ColumnSpec] = &[ + ColumnSpec { column: "f_id", json_key: "id", default: None, numeric: false }, + ColumnSpec { column: "f_price", json_key: "price", default: None, numeric: true }, + ColumnSpec { column: "f_stock", json_key: "stock", default: None, numeric: false }, + ColumnSpec { column: "f_creator_time", json_key: "creatorTime", default: None, numeric: false }, + ColumnSpec { column: "f_register_time", json_key: "registerTime", default: None, numeric: false }, + ]; + + const SYNTH_SPEC: EntitySpec = EntitySpec { + app_code: "synth", + entity: "Widget", + table: "synth_widget", + module_key: None, + columns: SYNTH_COLUMNS, + numeric_columns: &["f_price"], + creator_fixed: None, + }; + + /// 投影里**每一列都带双引号别名**,且 numeric 列 `::text`、时间列 `to_char`。 + #[test] + fn projection_uses_quoted_aliases() { + let proj = projection(&SYNTH_SPEC).expect("投影构造"); + assert!(proj.contains(r#"f_id AS "id""#), "投影: {proj}"); + assert!(proj.contains(r#"f_price::text AS "price""#), "投影: {proj}"); + assert!( + proj.contains(r#"to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime""#), + "投影: {proj}" + ); + // 🔴 不得出现 `SELECT *`。 + assert!(!proj.contains('*'), "投影: {proj}"); + } + + /// 投影列数 = spec 列数(**每一列都不许漏**)。 + #[test] + fn projection_covers_every_spec_column() { + let proj = projection(&SYNTH_SPEC).expect("投影构造"); + let count = proj.split(" AS ").count() - 1; + assert_eq!(count, SYNTH_SPEC.columns.len(), "投影列数不对"); + } + + /// `body_id` 的判定与 `sys.rs::body_id` 一致(裁决 S20)。 + #[test] + fn body_id_semantics() { + let mut obj = Map::new(); + assert_eq!(body_id(&obj), None, "键不存在 ⇒ 无 id"); + obj.insert("id".to_string(), Value::Null); + assert_eq!(body_id(&obj), None, "null ⇒ 无 id"); + obj.insert("id".to_string(), Value::String(String::new())); + assert_eq!(body_id(&obj), None, "空串 ⇒ 无 id"); + obj.insert("id".to_string(), Value::String("abc".to_string())); + assert_eq!(body_id(&obj), Some("abc".to_string())); + obj.insert("id".to_string(), Value::Number(123.into())); + assert_eq!(body_id(&obj), Some("123".to_string()), "数字也算有 id"); + } + + /// 写入口的类型转换:`f_price` ⇒ numeric、`f_stock` ⇒ integer、`*_time` ⇒ timestamp。 + #[test] + fn write_casts() { + assert_eq!(write_cast("f_price"), "::numeric"); + assert_eq!(write_cast("f_stock"), "::integer"); + assert_eq!(write_cast("f_delete_mark"), "::integer"); + assert_eq!(write_cast("f_creator_time"), "::timestamp"); + // 🔴 `_time` 后缀是**通用规则**(不是逐列枚举)⇒ 业务表自带的时间列自动带上转换。 + assert_eq!(write_cast("f_register_time"), "::timestamp"); + assert_eq!(write_cast("f_title"), ""); + } + + /// body 值 ⇒ 文本:字符串原样、数字 / 布尔转文本、null / 对象 / 数组 ⇒ None。 + #[test] + fn value_to_text_rules() { + assert_eq!( + value_to_text(Some(&Value::String("x".to_string()))), + Some("x".to_string()) + ); + assert_eq!( + value_to_text(Some(&Value::Number(100.into()))), + Some("100".to_string()) + ); + assert_eq!( + value_to_text(Some(&Value::Bool(true))), + Some("true".to_string()) + ); + assert_eq!(value_to_text(Some(&Value::Null)), None); + assert_eq!(value_to_text(Some(&Value::Array(vec![]))), None); + assert_eq!(value_to_text(None), None); + } + + /// spec 的 json_key 与契约映射不一致 ⇒ 报错(而不是静默产出错键名)。 + #[test] + fn json_key_mismatch_is_rejected() { + let bad = ColumnSpec { + column: "f_title", + json_key: "Title", + default: None, + numeric: false, + }; + assert!(json_key_of(&bad).is_err()); + } + + /// 🔴 **numeric 列必须落在 `write_cast` 的 `::numeric` 映射里**。 + /// + /// 少了这层转换 ⇒ PG 报 `column is of type numeric but expression is of type text` + /// ⇒ 只在**运行时**变成「系统异常」信封,编译期 / 启动期无任何提示。 + /// + /// 🔴 **M2 的做法与它的取舍**(原来这个测试遍历 `crate::modules::all_specs()`): + /// 搬进 core crate 后 core **不许依赖业务层**(壳依赖 core ⇒ 反向依赖 = 循环依赖), + /// 所以遍历对象换成**本文件的合成 spec**。 + /// ⚠️ **已知技术债(不在 M2 修,M2 只搬迁不改行为)**: + /// `write_cast` 的 numeric 判定是**列名枚举**(`f_price`),而 spec 的 `col.numeric` + /// 是**声明** ⇒ 两处各写一份,**可能不同步**。 + /// 现有业务表的 numeric 列恰好都叫 `f_price`,所以至今没暴雷; + /// 但新业务表若用 `f_amount` 这类列名 + `numeric: true` ⇒ 写入缺 `::numeric` + /// ⇒ **运行期**才炸(本测试抓不到,因为它不遍历业务 spec 了)。 + /// ⇒ 真正的修法是让 `write_cast` **读 spec 的 `col.numeric`**(单一真源), + /// 那是**行为变更**,必须单独一批并让壳层的 `tests/crud_it.rs` 一起跑。 + #[test] + fn every_numeric_spec_column_has_a_numeric_write_cast() { + let mut numeric_cols = 0usize; + for col in SYNTH_SPEC.columns { + if col.numeric { + numeric_cols += 1; + assert_eq!( + write_cast(col.column), + "::numeric", + "{} 的 {} 是 numeric 列,写入必须带 ::numeric", + SYNTH_SPEC.table, + col.column + ); + } + } + assert!(numeric_cols > 0, "必须至少有一个 numeric 列(否则本测试空转)"); + // 其余硬编码的类型转换也一并钉住。 + assert_eq!(write_cast("f_stock"), "::integer"); + assert_eq!(write_cast("f_delete_mark"), "::integer"); + assert_eq!(write_cast("f_creator_time"), "::timestamp"); + } +} diff --git a/crates/sspf-core/src/db.rs b/crates/sspf-core/src/db.rs new file mode 100644 index 0000000..a02828c --- /dev/null +++ b/crates/sspf-core/src/db.rs @@ -0,0 +1,13 @@ +//! db —— 数据库访问(**转发到 [`sspf_store::db`]**)。 +//! +//! 🔴 真值源在 `crates/sspf-store/src/db.rs`(存储层,**不认识 HTTP**)。 +//! 本文件只做转发,保持 `crate::db::*` 这个既有路径可用 ⇒ +//! 拆分 crate 对上层零感知(业务层、集成测试、引文行号都不用动)。 +//! +//! 契约:`docs/contract.md` §5.4 / §5.5。 +//! DDL 唯一真源:`src/backend/db/schema.sql`(**不在 web root**,杜绝 DDL 可被 HTTP 下载)。 +//! +//! 🔴 为什么独立成 crate:存储层要给低代码引擎、后台任务、CLI、MCP 适配器共用, +//! 不能因为「内核用 axum」就让所有消费者都拖一个 web 框架(见 `PLAN.md` §3.2 AR6)。 + +pub use sspf_store::db::*; diff --git a/crates/sspf-core/src/entity.rs b/crates/sspf-core/src/entity.rs new file mode 100644 index 0000000..c216406 --- /dev/null +++ b/crates/sspf-core/src/entity.rs @@ -0,0 +1,11 @@ +//! entity —— **业务实体 spec 的类型定义**(转发到契约层)。 +//! +//! 🔴 真值源在 [`sspf_contract::entity`](契约层)。 +//! 本文件只做转发,原因是 `crate::entity::*` 是既有路径, +//! 业务层与测试都这么引用;保持路径稳定 ⇒ 拆分 crate 对上层零感知。 +//! +//! 🔴 **本文件只放「类型」,不放任何业务 spec** —— 业务 spec 住在 `packs//`。 +//! +//! 契约:`docs/contract.md` §5.3(精确列清单 = 投影真源)+ §6.4(端点)+ §9(接口)。 + +pub use sspf_contract::entity::{ColumnSpec, EntitySpec}; diff --git a/crates/sspf-core/src/envelope.rs b/crates/sspf-core/src/envelope.rs new file mode 100644 index 0000000..645fcbc --- /dev/null +++ b/crates/sspf-core/src/envelope.rs @@ -0,0 +1,79 @@ +//! envelope —— `ActionResult{code,msg,data}` 统一信封(**HTTP 包装层**)。 +//! +//! 🔴 **类型与码表在 [`sspf_contract::envelope`]**(契约层,不依赖 axum)。 +//! 本文件只负责把它包成 `axum::Json`,以及钉住「业务失败恒 HTTP 200」这一条。 +//! +//! 契约(**不得改动**,见 `docs/contract.md` §2 与 §1.2): +//! ```json +//! { "code": 200, "msg": "成功", "data": null } +//! ``` +//! +//! - 业务失败(`400` / `600` / `403`)**恒 HTTP 200**,成败只看 body 的 `code`。 +//! - 唯一**传输层**例外:未知路由 404、方法不对 405 —— 但 body 仍是本信封形状。 +//! - `data` 原样透传,失败时恒为 `null`。 + +use axum::Json; +use serde_json::Value; + +pub use sspf_contract::envelope::{code, ActionResult}; + +/// 成功信封:`code=200`、`msg="成功"`、`data` **原样透传**。 +pub fn ok(data: Value) -> Json { + Json(ActionResult::ok(data)) +} + +/// 失败信封:`code=`、`msg=`、`data=null`。 +/// +/// 🔴 **恒 HTTP 200** —— 业务失败不是传输层错误,别在这里改状态码。 +pub fn fail(code: i32, msg: impl Into) -> Json { + Json(ActionResult::fail(code, msg)) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 🔴 业务失败**恒 HTTP 200** —— 把 `fail()` 挂到真实 router 上,用裸 TCP 发一次请求验证状态码。 + /// (`docs/contract.md` §1.2 / §12 的验收点:业务失败是 HTTP 200,不是 4xx。) + #[tokio::test] + async fn fail_responds_with_http_200_and_envelope_body() { + use tokio::io::{AsyncReadExt, AsyncWriteExt}; + + let app = axum::Router::new().route( + "/boom", + axum::routing::get(|| async { fail(400, "账号已存在:smoke_user") }), + ); + + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); + let addr = listener.local_addr().unwrap(); + let server = tokio::spawn(async move { + axum::serve(listener, app).await.unwrap(); + }); + + let mut stream = tokio::net::TcpStream::connect(addr).await.unwrap(); + // 🔴 收发都套超时:没有超时的话,服务端不响应时这个测试会**永久挂住**而不是失败。 + let mut raw = Vec::new(); + tokio::time::timeout(std::time::Duration::from_secs(5), async { + stream + .write_all(b"GET /boom HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") + .await + .unwrap(); + stream.read_to_end(&mut raw).await.unwrap(); + }) + .await + .expect("HTTP 往返超时(5s)——业务失败必须立刻返回 HTTP 200,不该挂住"); + server.abort(); + + let raw = String::from_utf8_lossy(&raw).to_string(); + let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + assert!( + head.starts_with("HTTP/1.1 200 OK"), + "业务失败必须是 HTTP 200,实际响应头: {head}" + ); + + let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); + assert_eq!(body["code"], 400); + assert_eq!(body["msg"], "账号已存在:smoke_user"); + assert_eq!(body["data"], Value::Null); + } +} diff --git a/crates/sspf-core/src/guard.rs b/crates/sspf-core/src/guard.rs new file mode 100644 index 0000000..adea005 --- /dev/null +++ b/crates/sspf-core/src/guard.rs @@ -0,0 +1,329 @@ +//! guard —— **生产档弱密钥守卫**(平台层,纯函数 + 一次库回读)。 +//! +//! 🔴 **本仓自定判据**,**不是**照抄兄弟项目 `tdc-rs` 的 `ProdGuard` —— +//! 那个守卫是 `tdc-rs` 的 **Java 上游真源**(`ssw.common.guard.ProdGuard`)的移植, +//! 本仓**没有**对应的上游(本仓的上游是 react 版 + 官方 JNPF Java,两者都不含这个守卫), +//! ⇒ 照抄过来只会得到「六条判据看着严,其实管的是别人的弱值面」。 +//! +//! **本仓的弱值面只有两处**: +//! 1. `SEED_ADMIN_PASSWORD`(env)—— 缺省 `123456`(契约 §8.6 的 admin 种子口令)。 +//! 🔴 这是本仓**唯一**的「拿到就能登录」的口令 ⇒ 生产档必须换掉。 +//! 2. `CIPHER_KEY` —— **协议共享值**(前端要用它加密口令)⇒ **故意不受管**(见下)。 +//! +//! 🔴 **协议共享值不受管**:`cipher.rs` 的 `CIPHER_KEY` 必须是 `md5_hex` 的**输入**, +//! 官方前端的 `cipher.ts` 用的是**同一个**常量 ⇒ 改它 ⇒ 前端加密出来的密文解不开 +//! ⇒ **整个登录链路当场报废**。它不是「忘了改的弱密钥」,它是**契约的一部分** +//! ⇒ 判据①(键不在本部署的清单里 ⇒ 跳过)在这里生效:本守卫的清单里**没有**它。 +//! +//! ## 档位 +//! +//! `SSW_PROFILE` env:`dev`(**缺省**)/ `prod`。 +//! - `dev`(缺省):**一律不判**(本仓的默认形态就是「本地开发/演示」), +//! ⇒ 契约与冒烟脚本**零影响**(种子口令恒 `123456`)。 +//! - `prod`:**下面六条判据逐条生效**,任一违规 ⇒ **拒绝启动**(人话报错 + `exit 1`)。 +//! +//! ## 六条判据(弱值判定,通用口径) +//! +//! ① **键不在本部署的清单里** ⇒ **跳过**(不判本部署根本没有的键)。 +//! ② 值为 `null` / 空白 ⇒ 违规。 +//! ③ 值**精确等于**已知弱值 ⇒ 违规。 +//! ④ 值**含**已知弱值 ⇒ 违规(**反绕过**:只比精确值时,`123456x` 能溜过去)。 +//! ⑤ 值命中**弱标记词**(**整体词**匹配,不是子串)⇒ 违规。 +//! ⑥ 长度 < [`MIN_LEN`] ⇒ 违规。 +//! +//! —— 并且:**强值必放行**(防「守卫恒红」:一条判据写错就再也起不来了)。 + +use crate::db::Db; + +/// 生产档口令的**最小长度**(判据⑥)。 +pub const MIN_LEN: usize = 12; + +/// 部署档位(**定义在 [`crate::config`]**,这里转发保持既有路径可用)。 +/// +/// 🔴 档位是「配置」不是「安全判定」:它从 env 读、决定判据要不要生效。 +/// 定义在 guard 里会造成 `config → guard → db` 的**假依赖** —— +/// 拆 crate 时会变成真循环依赖,必须提前断开。 +pub use crate::config::Profile; + +/// 已知弱值 —— **精确相等**即违规(判据③)。 +/// +/// 🔴 只收**本仓真会出现的**弱值:`123456` 是本仓的 admin 种子口令(契约 §8.6), +/// 其余是通用弱口令 ⇒ 换一份实现时**不必**改这里。 +pub const WEAK_EXACT: &[&str] = &[ + "123456", "admin", "admin123", "password", "changeme", "12345678", "111111", "000000", +]; + +/// 已知弱值 —— **包含**即违规(判据④,反绕过)。 +/// +/// 🔴 **只收「不作为更长单词子串出现」的 token**:`admin` 不在里面 +/// (`administrator` 含 `admin` ⇒ 会误伤);`password` 在里面 +/// (`password123` 必是弱值)。 +pub const WEAK_CONTAINS: &[&str] = &["123456", "changeme", "password", "qwerty", "letmein"]; + +/// 弱标记词 —— **整体词**命中即违规(判据⑤)。 +/// +/// 匹配口径:把值按**非字母数字**切成词,逐词**全等**比较 ⇒ +/// `demo-2024` 命中 `demo`;`demonstration` **不**命中(那是一个整词 `demonstration`)。 +pub const WEAK_MARKER_WORDS: &[&str] = &[ + "demo", "test", "example", "sample", "default", "admin", "guest", "user", "temp", +]; + +/// 一条违规(**点名**是哪个键、哪条判据 ⇒ 报错能直接指向要改什么)。 +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct Violation { + /// 违规的键名。 + pub key: String, + /// 违规原因(人话,含判据编号)。 + pub reason: String, +} + +impl std::fmt::Display for Violation { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{}:{}", self.key, self.reason) + } +} + +/// 把值按**非字母数字**切成词(判据⑤的分词口径)。 +fn words_of(value: &str) -> Vec { + value + .split(|c: char| !c.is_alphanumeric()) + .filter(|w| !w.is_empty()) + .map(|w| w.to_ascii_lowercase()) + .collect() +} + +/// 判定**单个**值是否弱(返回全部违规原因;空 vec = 通过)。 +/// +/// 🔴 **纯函数**(不读 env、不读库、不看全局状态)⇒ 可单测、可在别处复用。 +/// +/// 🔴 判据③ 只比**精确相等**(大小写不敏感);判据④ 比**包含**(大小写不敏感)。 +pub fn weak_reasons(value: &str) -> Vec { + let mut reasons = Vec::new(); + let trimmed = value.trim(); + + // ② 空 / 空白 + if trimmed.is_empty() { + reasons.push("判据②:值为空/空白".to_string()); + // 空值也必然过不了 ⑥,但只报一次 ⇒ 直接返回。 + return reasons; + } + + let lower = trimmed.to_ascii_lowercase(); + + // ③ 精确等于已知弱值 + if WEAK_EXACT.iter().any(|w| lower == w.to_ascii_lowercase()) { + reasons.push(format!("判据③:值等于已知弱值({trimmed})")); + } + + // ④ 包含已知弱值(反绕过) + if let Some(hit) = WEAK_CONTAINS + .iter() + .find(|w| lower.contains(&w.to_ascii_lowercase())) + { + reasons.push(format!("判据④:值包含已知弱值({hit})")); + } + + // ⑤ 命中弱标记词(整体词) + let words = words_of(trimmed); + if let Some(hit) = WEAK_MARKER_WORDS + .iter() + .find(|w| words.iter().any(|word| word == &w.to_ascii_lowercase())) + { + reasons.push(format!("判据⑤:值命中弱标记词({hit})")); + } + + // ⑥ 长度下限 + if trimmed.chars().count() < MIN_LEN { + reasons.push(format!( + "判据⑥:长度 {} < {MIN_LEN}", + trimmed.chars().count() + )); + } + + reasons +} + +/// 判定**单个**值是否弱(只看是否违规,不看原因)。 +pub fn is_weak(value: &str) -> bool { + !weak_reasons(value).is_empty() +} + +/// 生产档的**配置级**守卫:逐个键判,返回全部违规。 +/// +/// 🔴 **键不在清单里 ⇒ 不判**(判据①):调用方只把「本部署真有的键」放进来。 +/// +/// - `values` = 本部署真实存在的键值对(如 `[(键名, 值)]`)。 +pub fn check_values(values: &[(String, String)]) -> Vec { + let mut out = Vec::new(); + for (key, value) in values { + for reason in weak_reasons(value) { + out.push(Violation { + key: key.clone(), + reason, + }); + } + } + out +} + +/// 把违规渲染成人话(**点名键 + 原因**),供启动失败时打印。 +pub fn render_violations(violations: &[Violation]) -> String { + let mut s = String::new(); + for (i, v) in violations.iter().enumerate() { + if i > 0 { + s.push('\n'); + } + s.push_str(" - "); + s.push_str(&v.to_string()); + } + s +} + +/// 🔴 **库内**校验:admin 账号当前的口令**是不是已知弱值**(生产档)。 +/// +/// 🔴 **为什么必须回读库里那行**:种子口令只对**空库**生效(`first_seed` 仅当 +/// `base_user` 行为 0 时跑)⇒ 生产库里 admin 的口令可能是**当初**种下的 +/// `123456`,而运维**后来**才设了 `SEED_ADMIN_PASSWORD` ⇒ +/// **配置看着是强的、库里其实是弱的** ⇒ 只查配置 = 守卫形同虚设。 +/// +/// 🔴 **为什么只比「已知弱值」而不是比「配置里那个」**:管理员**合法**在界面上 +/// 改过口令后,库里那个自然不等于配置里那个 ⇒ 若拿配置去比, +/// **每次改完口令都得改配置**,否则服务起不来 ⇒ 那是误伤。 +/// 本守卫只回答「这个口令是不是**人人皆知的弱口令**」⇒ 改过口令 ⇒ 放行; +/// 还是默认的 `123456` ⇒ 拦。 +/// +/// - `db`:库句柄。 +/// +/// 返回 `Ok(())` = 通过;`Err(msg)` = 人话错误。 +pub async fn verify_stored_admin_password(db: &Db) -> Result<(), String> { + let rows = db + .query_json( + "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"password\" \ + FROM base_user WHERE f_is_administrator = 1 ORDER BY f_id LIMIT 1", + ) + .await + .map_err(|e| format!("读取 admin 行失败: {e}"))?; + + let Some(row) = rows.first() else { + // 没有 admin 行 ⇒ 不是「弱口令」,是「没建账号」⇒ 不归本守卫管。 + return Ok(()); + }; + + let stored = row["password"].as_str().unwrap_or_default(); + if stored.is_empty() { + return Err("admin 行的 f_password 为空 ⇒ 无法校验(请在管理界面重置口令)".to_string()); + } + + // 库里存的是 md5(明文) ⇒ 拿每个弱值的 md5 去比。 + for weak in WEAK_EXACT { + if stored.eq_ignore_ascii_case(&crate::cipher::md5_hex(weak)) { + return Err(format!( + "admin 账号的库内口令仍是**已知弱口令**({weak})—— \ + 种子口令只对空库生效,库里是当初种下的那个。\ + 请在管理界面重置 admin 口令,或清库重来。" + )); + } + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn reasons(v: &str) -> Vec { + weak_reasons(v) + } + + /// ⑥ 长度下限:短的 ⇒ 违规,长的 ⇒ 不因长度违规。 + #[test] + fn min_len_is_enforced() { + assert!(reasons("short1A!").iter().any(|r| r.contains("判据⑥"))); + assert!(!reasons("Xk9mQ2vL7pR4zW8").iter().any(|r| r.contains("判据⑥"))); + } + + /// ③ 精确弱值 ⇒ 违规。 + #[test] + fn exact_weak_value_is_blocked() { + assert!(reasons("123456").iter().any(|r| r.contains("判据③"))); + assert!(reasons("admin").iter().any(|r| r.contains("判据③"))); + } + + /// ④ **反绕过**:默认口令加个后缀 ⇒ 仍然违规。 + #[test] + fn weak_value_with_suffix_is_blocked() { + assert!(reasons("123456x").iter().any(|r| r.contains("判据④"))); + } + + /// ④ 不得误伤 `administrator`(`admin` 只在**精确**与**整体词**两条里)。 + #[test] + fn administrator_is_not_a_false_positive() { + let rs = reasons("administrator9Q!x"); + assert!( + !rs.iter().any(|r| r.contains("判据④")), + "administrator 不该命中判据④:{rs:?}" + ); + } + + /// ⑤ 弱标记词:**整体词**命中,不是子串。 + /// + /// 🔴 分词口径 = 按**非字母数字**切 ⇒ `demo-2024` 是两个词(`demo` 命中), + /// 而 `demo2024` 是**一个词**(`demo` 不命中)——这是「整体词」的设计后果, + /// 避免 `administrator` / `demonstration` 这类正常词被误伤。 + #[test] + fn marker_word_is_whole_word_only() { + assert!(reasons("demo-2024Q!x").iter().any(|r| r.contains("判据⑤"))); + assert!(!reasons("demonstration9Q!x") + .iter() + .any(|r| r.contains("判据⑤"))); + } + + /// 🔴 `demo2024` 这类**连写**的弱口令:⑤ 不命中(整体词),但 **⑥ 长度**兜住。 + /// + /// ⇒ 钉住「六条判据是**并集**,不是各自独立」:任一条命中即违规。 + #[test] + fn joined_marker_is_caught_by_the_length_rule() { + let rs = reasons("demo2024Q!x"); + assert!( + !rs.iter().any(|r| r.contains("判据⑤")), + "连写的 demo2024 不该命中整体词判据:{rs:?}" + ); + assert!( + rs.iter().any(|r| r.contains("判据⑥")), + "但它必须被长度判据兜住:{rs:?}" + ); + } + + /// ② 空值 ⇒ 违规。 + #[test] + fn blank_value_is_named() { + assert!(reasons(" ").iter().any(|r| r.contains("判据②"))); + } + + /// 🔴 **强值必放行**(防「守卫恒红」)。 + #[test] + fn strong_value_is_allowed() { + assert!(reasons("Xk9mQ2vL7pR4zW8").is_empty()); + assert!(!is_weak("Xk9mQ2vL7pR4zW8")); + } + + /// 档位解析:非法值回落 `Dev`(不误伤本地开发)。 + #[test] + fn profile_parses_leniently() { + assert_eq!(Profile::from_env_str("prod"), Profile::Prod); + assert_eq!(Profile::from_env_str("PRODUCTION"), Profile::Prod); + assert_eq!(Profile::from_env_str("prod "), Profile::Prod); + assert_eq!(Profile::from_env_str("dev"), Profile::Dev); + assert_eq!(Profile::from_env_str(""), Profile::Dev); + assert_eq!(Profile::from_env_str("productionn"), Profile::Dev); + } + + /// 守卫报错**点名键**(运维要能直接照着改)。 + #[test] + fn violation_message_names_the_key() { + let vs = check_values(&[("SEED_ADMIN_PASSWORD".to_string(), "123456".to_string())]); + assert!(!vs.is_empty()); + assert_eq!(vs[0].key, "SEED_ADMIN_PASSWORD"); + assert!(render_violations(&vs).contains("SEED_ADMIN_PASSWORD")); + } +} diff --git a/crates/sspf-core/src/ids.rs b/crates/sspf-core/src/ids.rs new file mode 100644 index 0000000..46b96a5 --- /dev/null +++ b/crates/sspf-core/src/ids.rs @@ -0,0 +1,8 @@ +//! ids —— 主键生成(36 位 UUID v4,转发到契约层)。 +//! +//! 🔴 真值源在 [`sspf_contract::ids`]。本文件只做转发,保持既有引用路径稳定。 +//! +//! 契约:规格 §「主键是 36 位 UUID v4(带连字符)」。 +//! `f_id` 存 `varchar(50)`,形状必须与基线平台一致,迁移期靠 `--data-only` 导数据。 + +pub use sspf_contract::ids::new_uuid; diff --git a/crates/sspf-core/src/lib.rs b/crates/sspf-core/src/lib.rs new file mode 100644 index 0000000..ed3fb0c --- /dev/null +++ b/crates/sspf-core/src/lib.rs @@ -0,0 +1,76 @@ +//! sspf-core —— **平台核心层**:契约实现(与业务无关的那一半)。 +//! +//! M2 起,这些模块从 `src/backend/src/platform/` 下沉到这里; +//! 原路径保留**转发壳**(`pub use sspf_core::*`)⇒ 上层零感知。 +//! +//! ## 这个 crate 装什么 +//! +//! | 模块 | 内容 | +//! |---|---| +//! | [`envelope`] | `ActionResult` 信封的 `axum::Json` 包装(业务失败恒 HTTP 200) | +//! | [`cipher`] | md5 + AES-256-ECB(与前端 `cipher.ts` 逐字节等价) | +//! | [`auth`] / [`session`] | 登录、会话表、票据表 | +//! | [`authorization`] | 菜单树、权限编码判定 | +//! | [`guard`] | 生产档弱密钥守卫 | +//! | [`sys`] | `base_user` / `base_role` / `base_organize` / `base_module` 的管理 | +//! | [`seed`] | 两段式种子(`ensure_base` 幂等 + `first_seed` 首启) | +//! | [`crud`] | 业务实体的通用 CRUD 引擎(读 spec ⇒ 生成 SQL) | +//! | [`state`] | `AppState`(`config` / `db` / `sessions` / `tickets` 四个 `Arc`) | +//! | [`monitor`] | 宿主机资源快照 | +//! | [`registry`] | 多应用注册表(`base_system`) | +//! | [`variate_catalog`] | 公式编辑器函数目录(生成物) | +//! +//! ## 🔴 依赖纪律(由 `check-arch.sh` 的 AR9/AR10 钉住) +//! +//! | 允许 | 禁止 | +//! |---|---| +//! | `sspf-contract`(类型 / 码表)、`sspf-store`(db / config)、axum、serde、tokio、加密原语 | **业务包**(`sspf_pack_*`)—— 平台层不认识业务 | +//! | | **契约面**(面 B 的 `compat`)—— 平台层不反向依赖契约面 | +//! +//! 🔴 **为什么允许依赖 axum**:本层是「HTTP 包装层」—— 信封 `Json`、 +//! `Router`、extractor 都住这儿。它**不认识业务** ⇒ 不会把业务包拖进框架。 +//! +//! 🔴 **面 A / 面 B 的分流不在本 crate** —— 它在**装配根** +//! (`src/backend/src/routes.rs`):请求头 `Vue-Version: 3` ⇒ 官方形状。 +//! 分流点必须在装配根,否则本 crate 就要认识契约面 ⇒ 循环依赖(AR10)。 + +pub mod auth; +pub mod authorization; +pub mod cipher; +pub mod config; +pub mod crud; +pub mod db; +pub mod entity; +pub mod envelope; +pub mod guard; +pub mod ids; +pub mod menu; +pub mod monitor; +pub mod registry; +pub mod route; +pub mod seed; +pub mod session; +pub mod state; +pub mod sys; +pub mod variate_catalog; + +// ---------------------------------------------------------------- 顶层再导出 +// +// 🔴 **为什么再导出**:转发壳(`src/backend/src/platform/*.rs`)只做 +// `pub use sspf_core::*` ⇒ 若这里不列出模块,转发壳就转发不到。 + +pub use auth::{current_user, login_handler, require_login, require_login_any, require_module, resolve_user}; +pub use authorization::{build_menu_list, has_en_code_permission, has_module, MenuNode}; +pub use cipher::{decrypt_to_md5, md5_hex}; +pub use config::{Config, Profile}; +pub use crud::{crud_router, handle_delete, handle_list, handle_save}; +pub use db::Db; +pub use entity::{ColumnSpec, EntitySpec}; +pub use envelope::{code, fail, ok, ActionResult}; +pub use guard::Profile as GuardProfile; +pub use ids::new_uuid; +pub use menu::MenuSpec; +pub use registry::resolve_system_id; +pub use route::{HttpMethod, PackRoute, RouteAction, RouteGuard}; +pub use session::{SessionStore, TicketStore, TokenUser}; +pub use state::AppState; diff --git a/crates/sspf-core/src/menu.rs b/crates/sspf-core/src/menu.rs new file mode 100644 index 0000000..cd5a00e --- /dev/null +++ b/crates/sspf-core/src/menu.rs @@ -0,0 +1,11 @@ +//! menu —— **内置菜单 spec 的类型**(转发到契约层)。 +//! +//! 🔴 真值源在 [`sspf_contract::menu`](契约层)。本文件只做转发,保持既有引用路径稳定。 +//! +//! 🔴 **本文件只放「类型」,不放任何业务菜单** —— +//! 平台自带的那几条系统菜单在 [`crate::seed`] 里, +//! **业务菜单**由业务包各自声明(`packs//` 的 `*_MENU`)。 +//! +//! 契约:`docs/contract.md` §8.4(内置菜单)。 + +pub use sspf_contract::menu::MenuSpec; diff --git a/crates/sspf-core/src/monitor.rs b/crates/sspf-core/src/monitor.rs new file mode 100644 index 0000000..e2fd480 --- /dev/null +++ b/crates/sspf-core/src/monitor.rs @@ -0,0 +1,461 @@ +//! monitor —— 宿主机资源快照(`GET /api/system/Monitor` 的唯一数据源)。 +//! +//! 🔴 **不许编数字**:不装 `sysinfo`(本仓不引第三方系统信息 crate),只用 +//! `libc`(**已是 workspace 依赖**,`main.rs` 用它转 fd)+ `std` 读真实内核数据: +//! +//! | 指标 | Linux | macOS | +//! |---|---|---| +//! | 内存 | `/proc/meminfo`(`MemTotal` / `MemAvailable`) | `sysctlbyname("hw.memsize")` + `vm.page_free_count` / `vm.page_speculative_count` × `hw.pagesize` | +//! | CPU 使用率 | `/proc/stat` **两次采样差分**(精确 tick) | `getloadavg()` 的 1 分钟负载 ÷ 逻辑核数(**近似**,见下) | +//! | 磁盘 | `statvfs("/")` | `statvfs("/")` | +//! | 型号 / 核数 | `/proc/cpuinfo` | `machdep.cpu.brand_string` / `hw.*cpu` | +//! | 运行时长 | 进程启动时刻(`Instant`) | 同左 | +//! | 本机 IP | UDP `connect` 后读 `local_addr()`(不发包) | 同左 | +//! +//! 🔴 **为什么 macOS 的 CPU 用负载均值**:精确占空比要 `host_statistics(HOST_CPU_LOAD_INFO)`, +//! 而它返回的 `host_t` 是 mach port —— 每 2 秒轮询一次就必须 `mach_port_deallocate`, +//! 否则进程的 send right 会一路涨。为一个仪表盘数字引入 mach port 生命周期管理 +//! 不划算 ⇒ 用 `getloadavg()[0] / 逻辑核数 × 100`(**内核维护的真实负载**, +//! 只是 1 分钟平滑值,不是瞬时占空比)。契约里这条标 `partial` 并写明这一点。 +//! +//! 🔴 官方 `MonitorUtil` 为了算占空比**在主线程 sleep 1 秒** —— 本仓不这么干 +//! (监控页每 2 秒轮询一次,每请求睡 1 秒等于把线程池拖死),改成**记住上一次快照**。 + +use std::sync::OnceLock; +use std::time::Instant; + +use serde_json::{json, Value}; + +/// 进程启动时刻(`system.day` 用的是**进程运行时长**,与官方 `RuntimeMXBean` 同义)。 +fn started_at() -> Instant { + static START: OnceLock = OnceLock::new(); + *START.get_or_init(Instant::now) +} + +/// 字节数 ⇒ 人话(对齐 hutool `FormatUtil.formatBytes`:1024 进制、两位小数)。 +pub fn human_bytes(bytes: u64) -> String { + const UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"]; + let mut value = bytes as f64; + let mut index = 0usize; + while value >= 1024.0 && index + 1 < UNITS.len() { + value /= 1024.0; + index += 1; + } + if index == 0 { + format!("{bytes} B") + } else { + format!("{value:.2} {}", UNITS[index]) + } +} + +/// 百分比 ⇒ 两位小数字符串(前端口径:`state.cpu.used == '0.00'` 判零)。 +fn pct(value: f64) -> String { + format!("{:.2}", value.clamp(0.0, 100.0)) +} + +/// 进程运行时长 ⇒ 「N天M小时 / M小时K分 / K分」(对齐 hutool `formatBetween(HOUR)` 的粒度)。 +fn human_uptime(secs: u64) -> String { + let days = secs / 86_400; + let hours = (secs % 86_400) / 3_600; + let minutes = (secs % 3_600) / 60; + if days > 0 { + format!("{days}天{hours}小时") + } else if hours > 0 { + format!("{hours}小时{minutes}分") + } else { + format!("{minutes}分") + } +} + +/// 本机出口 IP —— 用 UDP `connect` 让内核选路后读 `local_addr`(**不发任何包**)。 +fn local_ip() -> String { + std::net::UdpSocket::bind("0.0.0.0:0") + .and_then(|socket| { + socket.connect("8.8.8.8:80")?; + socket.local_addr() + }) + .map(|addr| addr.ip().to_string()) + .unwrap_or_default() +} + +/// 磁盘 `(total, available)`(字节)—— `statvfs("/")`,两平台通用。 +fn disk_usage() -> (u64, u64) { + let Ok(path) = std::ffi::CString::new("/") else { + return (0, 0); + }; + // SAFETY: `statvfs` 只写我们提供的这块栈内存,`path` 是合法的 NUL 结尾 C 串。 + let mut stat: libc::statvfs = unsafe { std::mem::zeroed() }; + let rc = unsafe { libc::statvfs(path.as_ptr(), &mut stat) }; + if rc != 0 { + return (0, 0); + } + let block = stat.f_frsize.max(1) as u64; + let total = block.saturating_mul(stat.f_blocks as u64); + let available = block.saturating_mul(stat.f_bavail as u64); + (total, available) +} + +/// 一次采样的原始值。 +struct Raw { + cpu_name: String, + cpu_package: u32, + cpu_cores: u32, + cpu_logical: u32, + /// 已用 CPU 百分比 —— Linux 是 tick 差分,macOS 是负载均值折算。 + cpu_used: f64, + mem_total: u64, + mem_available: u64, + os: String, +} + +// ---------------------------------------------------------------- Linux + +#[cfg(target_os = "linux")] +fn collect() -> Raw { + // --- CPU:`/proc/stat` 首行 8 个累计 tick,存进全局再差分 --- + static PREV: std::sync::Mutex> = std::sync::Mutex::new(None); + fn read_ticks() -> Option<[u64; 4]> { + let text = std::fs::read_to_string("/proc/stat").ok()?; + let line = text.lines().next()?; + let mut fields = line.split_whitespace(); + if fields.next()? != "cpu" { + return None; + } + let mut nums = [0u64; 8]; + for (index, slot) in nums.iter_mut().enumerate() { + *slot = fields.next().and_then(|v| v.parse().ok()).unwrap_or(0); + let _ = index; + } + // [user+nice, system+irq+softirq+steal, idle+iowait, 0] + Some([ + nums[0] + nums[1], + nums[2] + nums[5] + nums[6] + nums[7], + nums[3] + nums[4], + 0, + ]) + } + let current = read_ticks(); + let cpu_used = { + let mut guard = PREV.lock().unwrap_or_else(|e| e.into_inner()); + let used = match (current, *guard) { + (Some(now), Some(prev)) => { + let delta: Vec = now + .iter() + .zip(prev.iter()) + .map(|(a, b)| a.saturating_sub(*b)) + .collect(); + let total: u64 = delta.iter().sum(); + if total == 0 { + 0.0 + } else { + (delta[0] + delta[1]) as f64 * 100.0 / total as f64 + } + } + // 第一次调用没有基准 ⇒ 用开机以来的平均(与 OSHI 首帧口径一致) + (Some(now), None) => { + let total: u64 = now.iter().sum(); + if total == 0 { + 0.0 + } else { + (now[0] + now[1]) as f64 * 100.0 / total as f64 + } + } + _ => 0.0, + }; + *guard = current; + used + }; + + // --- 内存:`/proc/meminfo` 的两个 kB 字段 --- + let meminfo = std::fs::read_to_string("/proc/meminfo").unwrap_or_default(); + let pick = |key: &str| -> u64 { + meminfo + .lines() + .find(|line| line.starts_with(key)) + .and_then(|line| line.split_whitespace().nth(1)) + .and_then(|v| v.parse::().ok()) + .map(|kb| kb * 1024) + .unwrap_or(0) + }; + let mem_total = pick("MemTotal:"); + let mem_available = pick("MemAvailable:"); + + // --- CPU 型号 / 核数:`/proc/cpuinfo` --- + let cpuinfo = std::fs::read_to_string("/proc/cpuinfo").unwrap_or_default(); + let cpu_name = cpuinfo + .lines() + .find(|line| line.starts_with("model name")) + .and_then(|line| line.split(':').nth(1)) + .map(str::trim) + .unwrap_or("unknown") + .to_string(); + let cpu_logical = cpuinfo + .lines() + .filter(|line| line.starts_with("processor")) + .count() as u32; + let mut core_ids: Vec = cpuinfo + .lines() + .filter(|line| line.starts_with("core id")) + .filter_map(|line| line.split(':').nth(1).map(|v| v.trim().to_string())) + .collect(); + core_ids.sort(); + core_ids.dedup(); + let cpu_cores = if core_ids.is_empty() { + cpu_logical + } else { + core_ids.len() as u32 + }; + let cpu_package = cpuinfo + .lines() + .filter(|line| line.starts_with("physical id")) + .filter_map(|line| line.split(':').nth(1).map(|v| v.trim().to_string())) + .collect::>() + .len() + .max(1) as u32; + + // --- 发行版名(`/etc/os-release` 的 PRETTY_NAME) --- + let os = std::fs::read_to_string("/etc/os-release") + .ok() + .and_then(|text| { + text.lines() + .find(|line| line.starts_with("PRETTY_NAME=")) + .map(|line| { + line.trim_start_matches("PRETTY_NAME=") + .trim_matches('"') + .to_string() + }) + }) + .filter(|name| !name.is_empty()) + .unwrap_or_else(|| format!("Linux {}", std::env::consts::ARCH)); + + Raw { + cpu_name, + cpu_package, + cpu_cores: cpu_cores.max(1), + cpu_logical: cpu_logical.max(1), + cpu_used, + mem_total, + mem_available, + os, + } +} + +// ---------------------------------------------------------------- macOS + +#[cfg(target_os = "macos")] +mod macos { + use std::ffi::CString; + + extern "C" { + fn sysctlbyname( + name: *const i8, + oldp: *mut std::ffi::c_void, + oldlenp: *mut usize, + newp: *mut std::ffi::c_void, + newlen: usize, + ) -> i32; + } + + /// 读一个整数型 sysctl(`u32` / `u64` 都吃:缓冲区清零,内核只写它需要的宽度)。 + pub fn sysctl_int(name: &str) -> Option { + let cname = CString::new(name).ok()?; + let mut value: u64 = 0; + let mut size = std::mem::size_of::(); + // SAFETY: 传入的都是本栈上的合法缓冲区;`size` 是它们的真实长度。 + let rc = unsafe { + sysctlbyname( + cname.as_ptr(), + &mut value as *mut u64 as *mut std::ffi::c_void, + &mut size, + std::ptr::null_mut(), + 0, + ) + }; + if rc == 0 { + Some(value) + } else { + None + } + } + + /// 读一个字符串型 sysctl。 + pub fn sysctl_string(name: &str) -> Option { + let cname = CString::new(name).ok()?; + let mut buffer = [0u8; 256]; + let mut size = buffer.len(); + // SAFETY: 同上,`buffer` 是 256 字节的栈数组。 + let rc = unsafe { + sysctlbyname( + cname.as_ptr(), + buffer.as_mut_ptr() as *mut std::ffi::c_void, + &mut size, + std::ptr::null_mut(), + 0, + ) + }; + if rc != 0 { + return None; + } + let end = buffer.iter().position(|b| *b == 0).unwrap_or(size.min(256)); + Some(String::from_utf8_lossy(&buffer[..end]).trim().to_string()) + } +} + +#[cfg(target_os = "macos")] +fn collect() -> Raw { + use macos::{sysctl_int, sysctl_string}; + + // --- CPU:1 分钟负载 ÷ 逻辑核数(见模块头注释「为什么用负载均值」) --- + let logical = sysctl_int("hw.logicalcpu").unwrap_or(1).max(1) as f64; + let mut load = [0.0f64; 3]; + // SAFETY: `getloadavg` 只写调用方给的 3 个 double。 + let rc = unsafe { libc::getloadavg(load.as_mut_ptr(), 3) }; + let cpu_used = if rc < 0 { + 0.0 + } else { + (load[0] / logical * 100.0).clamp(0.0, 100.0) + }; + + // --- 内存:总容量 + 空闲/可回收页 × 页大小 --- + let page_size = sysctl_int("hw.pagesize").unwrap_or(4096); + let free_pages = sysctl_int("vm.page_free_count").unwrap_or(0); + let speculative = sysctl_int("vm.page_speculative_count").unwrap_or(0); + let mem_total = sysctl_int("hw.memsize").unwrap_or(0); + let mem_available = (free_pages + speculative).saturating_mul(page_size); + + let cpu_name = sysctl_string("machdep.cpu.brand_string").unwrap_or_else(|| "Apple CPU".to_string()); + let cpu_cores = sysctl_int("hw.physicalcpu").unwrap_or(1).max(1) as u32; + let cpu_package = sysctl_int("hw.packages").unwrap_or(1).max(1) as u32; + + let os = match sysctl_string("kern.osproductversion") { + Some(version) if !version.is_empty() => { + format!("macOS {version} ({})", std::env::consts::ARCH) + } + _ => format!("macOS ({})", std::env::consts::ARCH), + }; + + Raw { + cpu_name, + cpu_package, + cpu_cores, + cpu_logical: logical as u32, + cpu_used, + mem_total, + mem_available: mem_available.min(mem_total), + os, + } +} + +// ---------------------------------------------------------------- 其它平台 + +#[cfg(not(any(target_os = "linux", target_os = "macos")))] +fn collect() -> Raw { + Raw { + cpu_name: "unknown".to_string(), + cpu_package: 1, + cpu_cores: 1, + cpu_logical: 1, + cpu_used: 0.0, + mem_total: 0, + mem_available: 0, + os: format!("{} ({})", std::env::consts::OS, std::env::consts::ARCH), + } +} + +/// 组装 `MonitorListVO` 形状(与官方 `jnpf/base/model/monitor/MonitorListVO` 逐字段对齐)。 +/// +/// 🔴 字段**全是字符串**(除 `time` / `coreNumber`):官方 `FormatUtil` / `DecimalFormat` +/// 出来的就是 `"15.93 GB"` / `"12.34"` 这种文本,前端直接贴到模板里。 +pub fn payload() -> Value { + let raw = collect(); + let (disk_total, disk_available) = disk_usage(); + let mem_used = raw.mem_total.saturating_sub(raw.mem_available); + let mem_rate = if raw.mem_total == 0 { + 0.0 + } else { + mem_used as f64 * 100.0 / raw.mem_total as f64 + }; + let disk_used = disk_total.saturating_sub(disk_available); + let disk_rate = if disk_total == 0 { + 0.0 + } else { + disk_used as f64 * 100.0 / disk_total as f64 + }; + let uptime = started_at().elapsed().as_secs(); + + json!({ + "system": { + "os": raw.os, + "day": human_uptime(uptime), + "ip": local_ip(), + }, + "cpu": { + "name": raw.cpu_name, + "package": format!("{}个物理CPU", raw.cpu_package), + "core": format!("{}个物理核心", raw.cpu_cores), + "coreNumber": raw.cpu_cores, + "logic": format!("{}个逻辑CPU", raw.cpu_logical), + "used": pct(raw.cpu_used), + "idle": pct(100.0 - raw.cpu_used), + }, + "memory": { + "total": human_bytes(raw.mem_total), + "available": human_bytes(raw.mem_available), + "used": human_bytes(mem_used), + "usageRate": pct(mem_rate), + }, + "disk": { + "total": human_bytes(disk_total), + "available": human_bytes(disk_available), + "used": human_bytes(disk_used), + "usageRate": pct(disk_rate), + }, + "time": chrono::Utc::now().timestamp_millis(), + }) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// 字节格式化:**1024 进制两位小数**(对齐 hutool `formatBytes`)。 + #[test] + fn human_bytes_matches_hutool_shape() { + assert_eq!(human_bytes(0), "0 B"); + assert_eq!(human_bytes(512), "512 B"); + assert_eq!(human_bytes(1024), "1.00 KB"); + assert_eq!(human_bytes(1024 * 1024 * 3 / 2), "1.50 MB"); + } + + /// 运行时长粒度:<1 小时只到分,<1 天到小时,>=1 天到天。 + #[test] + fn human_uptime_granularity() { + assert_eq!(human_uptime(90), "1分"); + assert_eq!(human_uptime(3 * 3600 + 120), "3小时2分"); + assert_eq!(human_uptime(2 * 86_400 + 5 * 3600), "2天5小时"); + } + + /// 🔴 **真采集**:本机跑测试时这些值必须是真的非零(不是占位 0)。 + /// 这条会把「采不到就填 0」的实现直接钉死 —— 0 就是失败。 + #[test] + fn payload_carries_real_host_metrics() { + let snap = payload(); + let mem_total = snap["memory"]["total"].as_str().unwrap_or_default(); + assert!( + mem_total != "0 B" && !mem_total.is_empty(), + "内存总量必须是真的(采不到会退化成 0 B):{mem_total}" + ); + let disk_total = snap["disk"]["total"].as_str().unwrap_or_default(); + assert!(disk_total != "0 B", "磁盘总量必须是真的:{disk_total}"); + let rate = snap["memory"]["usageRate"] + .as_str() + .unwrap_or_default() + .parse::() + .unwrap_or(-1.0); + assert!( + (0.0..=100.0).contains(&rate), + "内存使用率必须是 0..=100:{rate}" + ); + assert!(snap["time"].as_i64().unwrap_or(0) > 0, "时间戳必须是真的"); + } +} diff --git a/crates/sspf-core/src/registry.rs b/crates/sspf-core/src/registry.rs new file mode 100644 index 0000000..c79b34e --- /dev/null +++ b/crates/sspf-core/src/registry.rs @@ -0,0 +1,219 @@ +//! registry —— **多应用 / 多子系统**的注册表与路由(平台层)。 +//! +//! 契约:`docs/contract.md` §8.7(多应用)+ 官方 JNPF `base_system` / `App-Code`。 +//! +//! 🔴 **为什么叫 `registry` 而不是 `system`**:本仓的**契约面**按官方模块名组织 +//! (`compat/system.rs` = 官方面 B 的 system 端点集)。平台机制这一层要用 +//! **语义名**区分开 —— 它管的是「应用注册表」,不是「系统端点」。 +//! +//! 🔴 **机制(按官方 JNPF 平台做成多应用)**: +//! 1. **注册表** = `base_system` 表:每行一个应用,`f_en_code` 是该应用的 `App-Code`, +//! `f_id` 即下游所有 `base_module.f_system_id` 引用的系统 id; +//! 2. **路由** = 请求头 `App-Code` ⇒ [`app_code_of`] ⇒ [`resolve_system`] 解析出当前系统; +//! 3. **隔离** = `base_module` / 权限判据全部按 `f_system_id` 过滤 +//! (见 [`crate::authorization`];契约面侧的对应实现见 `platform::compat::helper::load_menus`, +//! **它住在契约面 crate,不在本 crate** —— 平台核心不许反向依赖契约面,见 AR10)。 +//! +//! 🔴 **`App-Code` 不是契约判别头**:判别「面 A / 面 B」只看 `Vue-Version: 3` +//! (`JNPF_COMPAT_SURFACE.md` §2.2)。`App-Code` 只选「当前应用」,且本仓前端 +//! 也发它 ⇒ 它**绝不能**当判别头(见 `face_b.rs::is_face_b` 的注释)。 +//! +//! 🔴 **缺省 / 未命中 ⇒ 主系统**(`MAIN_SYSTEM_CODE`)—— 与官方 +//! `JnpfConst.MAIN_SYSTEM_CODE` 默认行为一致:没有 `App-Code` 或值不认识时, +//! 回落到主系统,绝不报错(避免「不认识的应用码 ⇒ 全站 500」)。 + +use axum::http::HeaderMap; + +use crate::db::Db; + +/// 主系统的 id(`base_system.f_id`)。 +/// +/// 🔴 官方的主系统 `f_id` 是雪花号(初始化数据里是 `309228585019769285`), +/// 本仓用**可读字面量**自建种子(与内置菜单 id `m_sys` 同一风格); +/// 对外只承诺「`f_id` 稳定、下游 `f_system_id` 引用它」。 +pub const MAIN_SYSTEM_ID: &str = "mainSystem"; + +/// 主系统的编码(`base_system.f_en_code`,也即官方 `App-Code` 的值)。 +/// +/// 🔴 **官方常量**:`JnpfConst.MAIN_SYSTEM_CODE = "mainSystem"` +/// (`backend/jnpf-common/.../jnpf/constant/JnpfConst.java`)。 +/// 前端也硬比较这个值(`CollectPane.vue` / `CommonPane.vue` 里 +/// `systemCode === 'mainSystem'` 决定首页布局)⇒ **绝不能自造别的值**。 +pub const MAIN_SYSTEM_CODE: &str = "mainSystem"; + +/// 🔴 **选当前应用的请求头名**(官方 JNPF 用 `App-Code`;HTTP 头名大小写不敏感 ⇒ 小写)。 +pub const APP_CODE_HEADER: &str = "app-code"; + +/// 一个已解析出的系统引用。 +pub struct SystemRef { + /// 系统 id(`base_system.f_id`)—— 下游 `f_system_id` 引用它。 + pub id: String, + /// 系统编码(`base_system.f_en_code`,即 `App-Code`)。 + pub code: String, +} + +/// 从请求头读 `App-Code`(官方选当前应用的头;大小写不敏感,两侧空白忽略)。 +pub fn app_code_of(headers: &HeaderMap) -> Option { + headers + .get(APP_CODE_HEADER) + .and_then(|v| v.to_str().ok()) + .map(|v| v.trim().to_string()) + .filter(|s| !s.is_empty()) +} + +/// 🔴 **解析当前系统**: +/// - `App-Code` 命中 `base_system.f_en_code` ⇒ 返回该系统的 `(id, code)`; +/// - `App-Code` 缺失 ⇒ 按官方常量 [`MAIN_SYSTEM_CODE`] 查库(与显式传入完全同一条路径, +/// 这样即便部署方把主系统的 `f_id` 建成雪花号,`f_system_id` 也能对上); +/// - 未命中 / 查询失败 ⇒ 返回主系统常量(绝不报错、绝不 panic)。 +pub async fn resolve_system(db: &Db, app_code: Option<&str>) -> SystemRef { + let code = app_code.unwrap_or(MAIN_SYSTEM_CODE).to_string(); + let fallback = || SystemRef { + id: MAIN_SYSTEM_ID.to_string(), + code: MAIN_SYSTEM_CODE.to_string(), + }; + let rows = match db + .query_json_params( + "SELECT f_id AS \"id\", f_en_code AS \"code\" FROM base_system \ + WHERE f_en_code = $1::text LIMIT 1", + &[&code], + ) + .await + { + Ok(rows) => rows, + Err(e) => { + // 🔴 DB 报错 ⇒ 回落主系统(不冒泡、不 panic;解析失败不应让请求挂掉)。 + eprintln!("[system] 系统解析失败(按主系统处理): {e}"); + return fallback(); + } + }; + if let Some(row) = rows.first() { + let id = row["id"].as_str().unwrap_or(MAIN_SYSTEM_ID).to_string(); + let code = row["code"].as_str().unwrap_or(MAIN_SYSTEM_CODE).to_string(); + if !id.is_empty() { + return SystemRef { id, code }; + } + } + // 未知应用码:回落到主系统(显式传入 mainSystem 时也走这条 ⇒ 结果一致)。 + fallback() +} + +/// 便捷封装:只取系统 id(权限 / 菜单隔离判据用)。 +pub async fn resolve_system_id(db: &Db, app_code: Option<&str>) -> String { + resolve_system(db, app_code).await.id +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::authorization::{self, MenuNode}; + use crate::db::Db; + use crate::seed; + use tokio::sync::OnceCell; + + /// 🔴 **进程级共享实例**(pglite 是进程级全局单例 ⇒ 只能开一次)。 + static SHARED: OnceCell = OnceCell::const_new(); + + /// 🔴 **本 crate 自建库**(不经过壳层的 `bootstrap`)—— + /// core **不许依赖壳层**(壳依赖 core ⇒ 反向依赖 = 循环依赖)。 + /// ⇒ 这里只种**平台表 + 平台自带菜单**(`extra_menus` 传空切片), + /// 业务菜单由壳层的装配根注入(那是**壳**的事,不是 core 的)。 + async fn shared_db() -> &'static Db { + SHARED + .get_or_init(|| async { + let db = Db::open_temp().await.expect("打开 pglite 临时库失败"); + db.ensure_schema().await.expect("ensure_schema 失败"); + seed::ensure_base(&db, &[]).await.expect("ensure_base 失败"); + db + }) + .await + } + + /// 多应用:注册表解析 + 菜单按系统隔离。 + /// + /// 🔴 单库单测(pglite 进程级全局 ⇒ 只开一次): + /// 1. 不传 / 不认识 `App-Code` ⇒ 回落主系统; + /// 2. `base_system` 多行(主系统 + app-b)可按 `App-Code` 解析; + /// 3. 菜单按 `f_system_id` 隔离 —— 主系统看不到 app-b 的菜单,反之亦然。 + #[tokio::test] + async fn registry_resolution_and_menu_isolation() { + // 🔴 用进程级共享实例(pglite 只能开一次;绝不能各模块各 open_temp 一次)。 + let db = shared_db().await; + // 🔴 种平台表 + 平台自带菜单(**不注入业务菜单** —— 那是装配根的事)。 + seed::ensure_base(db, &[]).await.expect("ensure_base"); + + // ---- 注册表解析 ---- + // 缺省 ⇒ 主系统。 + let s = resolve_system(&db, None).await; + assert_eq!(s.id, MAIN_SYSTEM_ID); + assert_eq!(s.code, MAIN_SYSTEM_CODE); + // 不认识的 App-Code ⇒ 仍回落主系统(绝不报错)。 + assert_eq!(resolve_system(&db, Some("no-such-app")).await.id, MAIN_SYSTEM_ID); + // 命中 app-b ⇒ 解析出 app-b 的 (id, code)。 + let s = resolve_system(&db, Some("app-b")).await; + assert_eq!(s.id, "app-b"); + assert_eq!(s.code, "app-b"); + + // ---- 在 app-b 下塞一条独立菜单(模拟「另一个应用」的菜单)---- + db.exec_params( + "INSERT INTO base_module \ + (f_id, f_full_name, f_en_code, f_url_address, f_parent_id, f_type, \ + f_sort_code, f_system_id, f_enabled_mark, f_delete_mark, f_tenant_id) \ + VALUES ($1::text,$2::text,$3::text,$4::text,$5::text,$6::text::integer, \ + $7::text::bigint,$8::text,$9::text::integer,$10::text::integer,$11::text)", + &[ + &"m_appb_x".to_string(), + &"应用B菜单".to_string(), + &"permission.appb.x".to_string(), + &"appb/x".to_string(), + &"0".to_string(), + &"2".to_string(), + &"1".to_string(), + &"app-b".to_string(), + &"1".to_string(), + &"0".to_string(), + &"0".to_string(), + ], + ) + .await + .expect("insert app-b menu"); + + // 主系统(admin 看全部):5 条内置 + **业务层声明的全部业务菜单**,且不含 app-b 的菜单。 + // 🔴 `build_menu_list` 返回的是**树的根节点**(不是扁平列表)—— 内置菜单挂在 + // `m_sys` 下 ⇒ 主系统的根节点比节点总数少。隔离断言必须用**展平集合**判断。 + // 🔴 这里**不写死业务菜单条数**(否则每加一个业务模块就得改平台层 ⇒ 违反 + // 「加模块只碰业务层」)⇒ 只钉「5 条内置必须在、且不含异系统菜单」。 + let main_menus = authorization::build_menu_list(&db, "admin", 1, MAIN_SYSTEM_ID).await; + let main_ids = flat_ids(&main_menus); + for builtin in ["m_sys", "m_user", "m_role", "m_org", "m_menu"] { + assert!( + main_ids.iter().any(|id| id == builtin), + "主系统必须含内置菜单 {builtin}" + ); + } + assert!( + main_ids.len() >= 5, + "主系统菜单数不应少于 5 条内置,实际 {}", + main_ids.len() + ); + assert!( + !main_ids.iter().any(|id| id == "m_appb_x"), + "主系统不应含 app-b 的菜单(隔离被破坏)" + ); + // app-b 系统:只含它自己的 1 条菜单(展平后仍是 1 个节点)。 + let appb_menus = authorization::build_menu_list(&db, "admin", 1, "app-b").await; + let appb_ids = flat_ids(&appb_menus); + assert_eq!(appb_ids.len(), 1, "app-b 系统应只有 1 个菜单节点"); + assert_eq!(appb_ids[0], "m_appb_x"); + } + + /// 把菜单树展平成「全部节点 id」列表(含根与所有后代)。 + fn flat_ids(nodes: &[MenuNode]) -> Vec { + let mut out = Vec::new(); + for n in nodes { + out.push(n.id.clone()); + out.extend(flat_ids(&n.children)); + } + out + } +} diff --git a/crates/sspf-core/src/route.rs b/crates/sspf-core/src/route.rs new file mode 100644 index 0000000..7d9a0d0 --- /dev/null +++ b/crates/sspf-core/src/route.rs @@ -0,0 +1,13 @@ +//! route —— **业务包路由声明的类型**(转发到契约层)。 +//! +//! 🔴 真值源在 [`sspf_contract::route`](契约层)。本文件只做转发,保持既有引用路径稳定。 +//! +//! 🔴 **本文件只放「类型」,不放任何具体路由** —— +//! 业务包在自己的 `packs//src/lib.rs` 里声明路由, +//! 内核用 [`crate::crud::crud_router`] 按声明**生成**路由。 +//! +//! 🔴 **路径形状**:必须是官方 JNPF 形状(`/api/{模块}/{资源}/...`), +//! **不许**用面 A 的 `/api/ssw/{appCode}/{Entity}/{List|Save|Delete}` +//! (那是本仓自造的 ssw 约定 ⇒ 集成到官方 JNPF 时**全部作废**)。 + +pub use sspf_contract::route::{HttpMethod, PackRoute, RouteAction, RouteGuard}; diff --git a/crates/sspf-core/src/seed.rs b/crates/sspf-core/src/seed.rs new file mode 100644 index 0000000..7cc684f --- /dev/null +++ b/crates/sspf-core/src/seed.rs @@ -0,0 +1,1107 @@ +//! seed —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 +//! +//! 契约:`docs/contract.md` §8.4(内置菜单)/ §8.5(内置角色)/ §8.6(种子行为)。 +//! +//! 两段式: +//! - [`ensure_base`]:**每次启动都跑**,幂等 —— 只补缺项,**绝不覆盖已改值**; +//! - [`first_seed`]:**仅当 `base_user` 行数为 0 时**跑一次 —— 建 admin 用户 + 角色关联。 +//! +//! 🔴 **不复活软删行**:内置角色 / 内置菜单的存在性判定**不按 `f_delete_mark` 过滤** +//! (契约 §8.6 明确要求)⇒ 用户手动软删的行不会被种子「复活」。 +//! 🔴 **授权行同理**:`base_authorize` 的「已授权」判定也不按 `f_delete_mark` 过滤 +//! ⇒ 软删的授权行也算「已授权」⇒ 不补。 +//! +//! 🔴 **存在性判定必须与固定字面量 id 对齐**:内置角色按 +//! 「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判,内置菜单按 +//! 「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判 —— +//! INSERT 用的是**固定字面量 id**(`role_admin` / `m_user` …),若只按 +//! en_code / url 判,用户在 UI 改过内置项的这两个字段后就会「查不到 ⇒ 撞复合主键」 +//! ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户也没法用 UI 改回去)。 +//! +//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` 列 —— 用户 id 存在 +//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` 才有 `f_user_id`。 +//! 写错列 ⇒ 授权永远不生效且**静默**。 +//! 🔴 7 张 `base_*` 表的主键是复合键 `(f_id, f_tenant_id)`,`f_tenant_id` 是 +//! `NOT NULL DEFAULT '0'` ⇒ **INSERT 必须显式写 `f_tenant_id='0'`**。 + +use crate::cipher::md5_hex; +use crate::db::{pglite, pglite::ToSql, Db}; +use crate::ids::new_uuid; +use crate::menu::MenuSpec; +use crate::registry; + +/// 内置 admin 账号名(同时用作种子的 `f_creator_user_id`)。 +const ADMIN_ACCOUNT: &str = "admin"; + +/// 内置 admin 角色的 `f_en_code`(内置角色清单里 `admin` 的编码)。 +const ADMIN_ROLE_EN_CODE: &str = "admin"; + +/// 内置 admin 角色的**字面量** id(`first_seed` 的角色关联引用它)。 +const ADMIN_ROLE_ID: &str = "role_admin"; + +/// 内置角色(契约 §8.5)—— 逐字值,**不得改动**。 +const BUILTIN_ROLES: [BuiltinRole; 2] = [ + BuiltinRole { + id: "role_admin", + full_name: "管理员", + en_code: "admin", + sort_code: 1, + }, + BuiltinRole { + id: "role_user", + full_name: "使用者", + en_code: "user", + sort_code: 2, + }, +]; + +/// 🔴 **平台层自带的内置菜单**(契约 §8.4)—— 逐字值,**不得改动**。 +/// +/// 🔴 **只含「系统管理」那 5 条**(`system` / `system/User` / `system/Role` / +/// `system/Organize` / `system/Module`)—— 它们是**平台层自己的**菜单 +/// (平台层提供 `base_*` 的管理端点 ⇒ 菜单是平台层的资产)。 +/// +/// 🔴 **业务菜单不在这里**(`demo-item` / `shop/Product` / `books/Book` …)—— +/// 那是**业务知识** ⇒ 由业务层各自声明(`modules/.rs` 的 `*_MENU`) +/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 +/// +/// 🔴 **`en_code` 是面 B 的点权限判据**(官方 `@SaCheckPermission("permission.user")`) +/// —— 面 A 用 `f_url_address`、面 B 用 `f_en_code`,**两套并存**。 +const BUILTIN_MENUS: [MenuSpec; 5] = [ + MenuSpec { + id: "m_sys", + full_name: "系统管理", + en_code: "permission", + url_address: "system", + parent_id: "0", + menu_type: 1, + icon: Some("setting"), + sort_code: 1, + system_en_code: registry::MAIN_SYSTEM_CODE, + }, + MenuSpec { + id: "m_user", + full_name: "用户管理", + en_code: "permission.user", + url_address: "system/User", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 2, + system_en_code: registry::MAIN_SYSTEM_CODE, + }, + MenuSpec { + id: "m_role", + full_name: "角色管理", + en_code: "permission.role", + url_address: "system/Role", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 3, + system_en_code: registry::MAIN_SYSTEM_CODE, + }, + MenuSpec { + id: "m_org", + full_name: "机构管理", + en_code: "permission.organize", + url_address: "system/Organize", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 4, + system_en_code: registry::MAIN_SYSTEM_CODE, + }, + MenuSpec { + id: "m_menu", + full_name: "菜单管理", + en_code: "permission.menu", + url_address: "system/Module", + parent_id: "m_sys", + menu_type: 2, + icon: None, + sort_code: 5, + system_en_code: registry::MAIN_SYSTEM_CODE, + }, +]; + +/// 内置角色的一行(契约 §8.5)。 +struct BuiltinRole { + /// 字面量主键(`role_admin` / `role_user`)。 + id: &'static str, + /// 全名(`管理员` / `使用者`)。 + full_name: &'static str, + /// 编码(`admin` / `user`)—— **存在性判定的依据之一**(另一个是 `id`)。 + en_code: &'static str, + /// 排序码。 + sort_code: i64, +} + +/// 两段式种子的第一段:**补内置角色 / 内置菜单 / admin 授权**(幂等,每次启动都跑)。 +/// +/// 🔴 **`extra_menus` = 业务层声明的菜单**(`modules/.rs` 的 `*_MENU`)—— +/// 平台层**不认**任何业务菜单 ⇒ 业务菜单由**装配根** [`crate::bootstrap`] 传入 +/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 +/// +/// 契约 §8.6。行为要点: +/// 1. 内置角色按「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判存在、 +/// 内置菜单按「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判存在 +/// —— 🔴 **都不按 `f_delete_mark` 过滤** ⇒ 软删行不被复活。 +/// 2. admin 授权按 `(f_object_type='role', f_object_id, f_item_type='module', f_item_id)` +/// 判存在 —— 🔴 同样**不按 `f_delete_mark` 过滤**。 +/// 3. **只补缺项,绝不覆盖已改值**(人工改名 / 调序 / 软删都会被保留)。 +pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite::Error> { + let now = now_str(); + ensure_systems(db, &now).await?; + ensure_builtin_roles(db, &now).await?; + let all_menus = all_builtin_menus(extra_menus); + ensure_builtin_menus(db, &now, &all_menus).await?; + ensure_admin_authorizations(db, &now, &all_menus).await?; + // 🔴 消息业务分类字典(`base_business_category`):消息记录页左侧两级页签的数据源。 + // 缺了它页面只是「页签为空」,不报错 ⇒ 很容易一直没人发现,所以放在同一处种。 + ensure_business_category(db, &now).await?; + // 🔴 `businessType` 字典:单据规则(模板中心)的「业务分类」列/下拉的唯一数据源。 + // 同样是「缺了不报错、只是全空」的那类,一并种在这里。 + ensure_business_type_dict(db, &now).await?; + // 🔴 数据建模的两张平台字典:基准数据类型 + 常用表字段。 + // 数据建模的新建表表单**完全依赖**前者(类型下拉),后者是「一键插入常用列」。 + // 同样是「缺了不报错、下拉全空」⇒ 一起种在这里。 + ensure_data_type(db, &now).await?; + ensure_common_fields(db, &now).await?; + // 🔴 `Language` 字典:多语言配置页的**表头**就是它(一个语种一列)。 + // 缺了它列表只剩「翻译标记」一列、新建表单也没有语种可填 ⇒ 页面等于废的。 + ensure_language_dict(db, &now).await?; + Ok(()) +} + +/// 多应用注册表(`base_system`)—— 幂等、每次启动都跑。 +/// +/// 🔴 MVP 多应用机制的核心:先确保**主系统**存在,再确保一个用于演示隔离的 +/// **第二应用 `app-b`** 存在(它**不带任何菜单** ⇒ 只验证「注册表 + 路由 + 隔离」, +/// 不引入业务菜单、不破 `check-boundary.sh` 的 CP6 平台层菜单条数断言)。 +/// +/// 🔴 **存在性判定** = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」,**不按 `f_delete_mark` +/// 过滤**(软删行也算存在 ⇒ 不复活、不覆盖、不撞复合主键)。 +/// +/// 🔴 业务新增一个应用 = 在 `base_system` 加一行 + 让对应 `MenuSpec.system_en_code` 指向它 +/// ⇒ **不用改本函数之外的平台代码**(平台只按 `en_code` 查 `f_id`)。 +pub async fn ensure_systems(db: &Db, now: &str) -> Result<(), pglite::Error> { + // (id, en_code = App-Code, full_name, f_is_main, description) + const BUILTIN_SYSTEMS: [(&str, &str, &str, i32, &str); 2] = [ + (registry::MAIN_SYSTEM_ID, registry::MAIN_SYSTEM_CODE, "系统平台", 1, "主系统"), + ("app-b", "app-b", "演示应用B", 0, "第二个应用(无菜单,用于验证隔离)"), + ]; + for (id, en_code, full_name, is_main, description) in BUILTIN_SYSTEMS { + let id = id.to_string(); + let en_code = en_code.to_string(); + let existing = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_system \ + WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1", + &[&en_code, &id], + ) + .await?; + if !existing.is_empty() { + continue; + } + let full_name = full_name.to_string(); + let is_main = is_main.to_string(); + let description = description.to_string(); + let enabled_mark = "1".to_string(); + let sort_code = "0".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let params: [&(dyn ToSql + Sync); 11] = [ + &id, + &en_code, + &full_name, + &is_main, + &description, + &enabled_mark, + &sort_code, + &delete_mark, + &tenant_id, + &creator, + &now, + ]; + db.exec_params( + "INSERT INTO base_system \ + (f_id, f_en_code, f_full_name, f_is_main, f_description, f_enabled_mark, \ + f_sort_code, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text, \ + $6::text::integer, $7::text::bigint, $8::text::integer, \ + $9::text, $10::text, $11::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +/// 消息业务分类字典(`base_business_category`)—— 官方初始库里的**一级 + 二级**共 38 行。 +/// +/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 的 `INSERT INTO base_business_category` +/// (官方共 89 行;此处只取 `f_parent_id = '-1'` 的 5 个一级 + 其直接子级 33 个)。 +/// +/// 🔴 **id 沿用官方字面量**(雪花 id)—— 消息行的 `f_category` 存的是这些 id 的拼接, +/// id 一变,官方的历史消息就对不上分类。所以这 38 个 id **不得改动**。 +/// 🔴 **为什么不灌三级**:三级是「消息事件」粒度(`flow_todo_remind` 之类), +/// 本仓还没有产生消息的流程引擎 ⇒ 灌了也展示不到,只是 51 行死数据。 +/// 等真有消息落库再补(届时按官方 dump 续加到 [`BUSINESS_CATEGORIES`] 即可)。 +/// 🔴 `f_type` 官方种子一律 `0`(自定义分类才写 `1`,见 `BusinessCategoryController.addTag`)。 +const BUSINESS_CATEGORIES: [(&str, &str, &str, &str); 38] = [ + // ── 一级(`f_parent_id = '-1'`)──────────────────────────────── + ("2046493747218354176", "应用", "-1", "app"), + ("2046494412900536320", "流程", "-1", "flow"), + ("2046494560334516224", "系统", "-1", "sys"), + ("2046494646179336192", "公告", "-1", "announce"), + ("2046494880842256384", "其他", "-1", "other"), + // ── 二级 ────────────────────────────────────────────────────── + ("2046498207713857536", "应用授权", "2046493747218354176", "app_auth"), + ("2046498549667074048", "公告提醒", "2046494646179336192", "announce_remind"), + ("2046500072862126080", "签收提醒", "2046494412900536320", "flow_sign"), + ("2046500160736989184", "办理", "2046494412900536320", "flow_handle"), + ("2046500875702243328", "催办", "2046494412900536320", "flow_urge"), + ("2046501020737081344", "待办", "2046494412900536320", "flow_todo"), + ("2046501168506605568", "抄送", "2046494412900536320", "flow_cc"), + ("2046501319522521088", "转审", "2046494412900536320", "flow_transfer_review"), + ("2046501588842975232", "协办", "2046494412900536320", "flow_assist"), + ("2046501724960722944", "指派", "2046494412900536320", "flow_assign"), + ("2046501881433427968", "退回", "2046494412900536320", "flow_return"), + ("2046501986085507072", "撤销", "2046494412900536320", "flow_revoke"), + ("2046502107422527488", "超时", "2046494412900536320", "flow_timeout"), + ("2046502107422527491", "提醒", "2046494412900536320", "flow_notice"), + ("2046502333298380800", "异常", "2046494412900536320", "flow_exception"), + ("2046502439330385920", "评论", "2046494412900536320", "flow_comment"), + ("2046502572495343616", "同意", "2046494412900536320", "flow_approve"), + ("2046502674320461824", "结束", "2046494412900536320", "flow_end"), + ("2046502848119836672", "拒绝", "2046494412900536320", "flow_reject"), + ("2046502966558593024", "子流程", "2046494412900536320", "flow_subflow"), + ("2046503112767836160", "委托/代理通知", "2046494412900536320", "flow_delegate_rel"), + ("2046503688704495616", "委托操作通知", "2046494412900536320", "flow_delegate_op"), + ("2046504062601531392", "任务流通知", "2046494412900536320", "flow_notice_task"), + ("2046504062601531395", "决策流通知", "2046494412900536320", "flow_notice_decision"), + ("2046504380970176512", "流程编辑", "2046494412900536320", "flow_edit"), + ("2046504635065307136", "账户同步", "2046494560334516224", "sys_sync"), + ("2046504806578786304", "日程变更", "2046494560334516224", "sys_schedule_change"), + ("2046504806578786314", "日程邀请", "2046494560334516224", "sys_schedule_invite"), + ("2046505011386650624", "文档共享", "2046494560334516224", "sys_file"), + ("2046505115216646144", "运维安全", "2046494560334516224", "sys_operation"), + ("2046505268967247872", "登录安全", "2046494560334516224", "sys_login"), + ("2046505516032724992", "密码安全", "2046494560334516224", "sys_password"), + ("2058744163381415936", "消息通知", "2046494412900536320", "flow_message_notice"), +]; + +/// 灌业务分类字典 —— 幂等、每次启动都跑。 +/// +/// 🔴 **存在性按 `f_id` 判且不过滤 `f_delete_mark`**:管理员在 UI 里删掉某个分类 +/// (软删)后,这里不会再插回去 —— 与 [`ensure_base`] 的其余种子同一条口径。 +/// 🔴 顺序有意义:一级先插(`f_parent_id = '-1'`),二级引用它们 ⇒ 按常量里的 +/// 书写顺序插入即可(本常量就是一级在前)。 +pub async fn ensure_business_category(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 type_zero = "0".to_string(); + let delete_mark = "0".to_string(); + for (index, (id, full_name, parent_id, en_code)) in BUSINESS_CATEGORIES.iter().enumerate() { + let (id, full_name, parent_id) = + (id.to_string(), full_name.to_string(), parent_id.to_string()); + let (en_code, sort_code) = (en_code.to_string(), index.to_string()); + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_business_category WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 10] = [ + &id, + &full_name, + &parent_id, + &en_code, + &enabled_mark, + &type_zero, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_business_category \ + (f_id, f_full_name, f_parent_id, f_en_code, f_enabled_mark, f_type, \ + 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::bigint, $8::text::integer, \ + $9::text, $10::text::timestamp)", + ¶ms, + ) + .await?; + } + 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"; + +/// `Language` 字典**分类**行的固定 id(官方初始库 `jnpf_db_init.sql` 同值)。 +const LANGUAGE_DICT_ID: &str = "dc6b2542d94b407cac61ec1d59592901"; + +/// `Language` 字典的语种行(官方初始库同 id / 同顺序)。 +/// +/// 🔴 **这就是多语言配置页的表头**:`base_language` 里一行的 `f_language` 必须命中 +/// 这里的某个 `enCode`,否则那行在列表里**没有列可以落**(会被静默丢掉)。 +const LANGUAGE_TYPES: [(&str, &str, &str, i64); 2] = [ + // (id, 显示名, enCode = 语种代码, 是否默认) + ("097a648ca21943c8ab775d169b893725", "简体中文", "zh-CN", 1), + ("e73047ef52f44d11b5326bf340981ed1", "English", "en-US", 0), +]; + +/// 灌 `Language` 字典(分类 1 行 + 语种 2 行)—— 幂等,按 `f_id` 判存在。 +/// +/// 🔴 与 [`ensure_business_type_dict`] 同一口径:**不看 `f_delete_mark`** +/// ⇒ 管理员在 UI 里删掉的语种不会被下次启动又插回来。 +pub async fn ensure_language_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 = LANGUAGE_DICT_ID.to_string(); + let dict_name = "系统语言".to_string(); + let dict_code = "Language".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, is_default)) in LANGUAGE_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 is_default = is_default.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); 12] = [ + &id, + &parent_zero, + &full_name, + &en_code, + &is_default, + &enabled_mark, + &dict_id, + &sort_code, + &delete_mark, + &tenant_id, + &now, + &sort_zero, + ]; + db.exec_params( + "INSERT INTO base_dictionary_data \ + (f_id, f_parent_id, f_full_name, f_en_code, f_is_default, f_enabled_mark, \ + f_dictionary_type_id, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time, \ + f_simple_spelling) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, \ + $6::text::integer, $7::text, $8::text::bigint, $9::text::integer, \ + $10::text, $11::text::timestamp, $12::text)", + ¶ms, + ) + .await?; + } + Ok(()) +} + + +/// 灌 `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(()) +} + +/// 基准数据类型(`base_data_type`)—— 官方初始库的 7 行原样。 +/// +/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 里 `base_data_type` 的 7 条 INSERT。 +/// 元组是 `(f_id, f_full_name, f_en_code)`,`f_type = 1`(系统)、`f_jnpf_key = NULL`。 +/// +/// 🔴 **为什么要灌它**:数据建模的「新建表」表单把类型下拉写死成 +/// `getBasicDataTypeList().map(o => ({fullName: o.fullName, id: o.enCode}))` +/// ⇒ 这张表为空时下拉**一个选项都没有**,表单虽然能打开但根本建不出表。 +/// 🔴 id 沿用官方雪花 id:`base_data_type_mapping` / `base_data_type_relation` +/// 都按这个 id 关联(本仓暂未建那两张,但先对齐,省得以后迁移对不上)。 +const DATA_TYPES: [(&str, &str, &str); 7] = [ + ("804009215168379011", "整型", "int"), + ("804009215168379013", "浮点型", "float"), + ("804009215168379014", "小数类型", "decimal"), + ("804009215168379016", "日期类型", "datetime"), + ("804009215168379017", "字符串", "varchar"), + ("804009215168379018", "文本", "text"), + ("804009215168379019", "长整形", "bigint"), +]; + +/// 常用表字段(`base_common_fields`)—— 官方初始库的 10 行原样。 +/// +/// 真源:`jnpf_db_init.sql` 里 `base_common_fields` 的 10 条 INSERT。 +/// 元组是 `(f_id, f_field_name, f_data_type, f_data_length, f_allow_null, f_field)`。 +/// +/// 🔴 官方这 10 行全是 `f_category = '2'`(**常用字段**)+ `f_type = 2`(自定义)+ +/// `f_enabled_mark = 1` + `f_allow_delete = NULL`(不是 0 —— 前端按 +/// `allowDelete === 0` 判「不许删」⇒ NULL 与 1 等价,都允许删)。 +const COMMON_FIELDS: [(&str, &str, &str, &str, &str, &str); 10] = [ + ("804368984903285110", "主键", "varchar", "50", "0", "f_id"), + ("804368984903285111", "描述", "varchar", "500", "1", "f_description"), + ("804368984903285112", "排序码", "bigint", "50", "1", "f_sort_code"), + ("804368984903285113", "有效标志", "int", "50", "1", "f_enabled_mark"), + ("804368984903285114", "创建时间", "datetime", "50", "1", "f_creator_time"), + ("804368984903285115", "创建用户", "varchar", "50", "1", "f_creator_user_id"), + ("804368984903285116", "修改时间", "datetime", "50", "1", "f_last_modify_time"), + ("804368984903285117", "修改用户", "varchar", "50", "1", "f_last_modify_user_id"), + ("804368984903285118", "删除时间", "datetime", "50", "1", "f_delete_time"), + ("804368984903285119", "删除用户", "varchar", "50", "1", "f_delete_user_id"), +]; + +/// 灌基准数据类型(7 行)—— 幂等,按 `f_id` 判存在。 +/// +/// 🔴 与其它种子同一口径:**不看 `f_delete_mark`**(管理员删掉的不会复活)。 +pub async fn ensure_data_type(db: &Db, now: &str) -> Result<(), pglite::Error> { + let now = now.to_string(); + let tenant_id = "0".to_string(); + let type_system = "1".to_string(); + let delete_mark = "0".to_string(); + for (index, (id, full_name, en_code)) in DATA_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_data_type WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 8] = [ + &id, + &full_name, + &en_code, + &type_system, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_data_type \ + (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_delete_mark, f_tenant_id, \ + f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::bigint, \ + $6::text::integer, $7::text, $8::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +/// 灌常用表字段(10 行)—— 幂等,按 `f_id` 判存在。 +pub async fn ensure_common_fields(db: &Db, now: &str) -> Result<(), pglite::Error> { + let now = now.to_string(); + let tenant_id = "0".to_string(); + let category = "2".to_string(); + let type_custom = "2".to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + for (index, (id, field_name, data_type, data_length, allow_null, field)) in + COMMON_FIELDS.iter().enumerate() + { + let (id, field_name, data_type) = (id.to_string(), field_name.to_string(), data_type.to_string()); + let (data_length, allow_null, field) = + (data_length.to_string(), allow_null.to_string(), field.to_string()); + let sort_code = index.to_string(); + let existed = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_common_fields WHERE f_id = $1::text LIMIT 1", + &[&id], + ) + .await?; + if !existed.is_empty() { + continue; + } + let params: [&(dyn ToSql + Sync); 13] = [ + &id, + &category, + &type_custom, + &field_name, + &data_type, + &data_length, + &allow_null, + &field, + &enabled_mark, + &sort_code, + &delete_mark, + &tenant_id, + &now, + ]; + db.exec_params( + "INSERT INTO base_common_fields \ + (f_id, f_category, f_type, f_field_name, f_data_type, f_data_length, f_allow_null, \ + f_field, f_enabled_mark, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text::integer, $4::text, $5::text, $6::text, \ + $7::text::integer, $8::text, $9::text::integer, $10::text::bigint, \ + $11::text::integer, $12::text, $13::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +/// 把一个 `App-Code`(`base_system.f_en_code`)解析成系统 id(`base_system.f_id`)。 +/// +/// 🔴 用于把菜单种进正确的系统(`f_system_id`)—— 平台层**不认**具体 app 名, +/// 只按 `system_en_code` 去 `base_system` 查 ⇒ 业务声明属于哪个应用即可。 +/// 查不到 ⇒ 回落主系统 id(绝不报错)。 +async fn system_id_of(db: &Db, system_en_code: &str) -> String { + let en_code = system_en_code.to_string(); + let rows = match db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_system WHERE f_en_code = $1::text LIMIT 1", + &[&en_code], + ) + .await + { + Ok(r) => r, + Err(e) => { + eprintln!("[seed] 系统解析失败(按主系统处理): {e}"); + return registry::MAIN_SYSTEM_ID.to_string(); + } + }; + rows.first() + .and_then(|r| r["id"].as_str()) + .filter(|s| !s.is_empty()) + .map(str::to_string) + .unwrap_or_else(|| registry::MAIN_SYSTEM_ID.to_string()) +} + +/// 平台层自带菜单 + 业务层传入的菜单 = **本次要种的全部内置菜单**。 +/// +/// 🔴 顺序 = 平台层 5 条在前、业务菜单在后 ⇒ 菜单 id / `f_sort_code` 的 +/// 分配由**各自声明它的那一层**负责(平台层管 1–5,业务层管 6+)。 +fn all_builtin_menus(extra: &[MenuSpec]) -> Vec { + let mut all: Vec = BUILTIN_MENUS.to_vec(); + all.extend_from_slice(extra); + all +} + +/// 两段式种子的第二段:**首次启动**建 admin 用户 + 角色关联。 +/// +/// 契约 §8.6:**仅当 `base_user` 行数为 0 时**才跑(否则直接返回,什么都不做)。 +/// +/// 🔴 `admin_password` = admin 的**明文**口令(内部只算 md5,**永不外泄**)。 +/// 缺省走 [`crate::config::DEFAULT_SEED_ADMIN_PASSWORD`](`123456`,契约逐字要求), +/// 生产档可用 `SEED_ADMIN_PASSWORD` env 覆盖。 +pub async fn first_seed(db: &Db, admin_password: &str) -> Result<(), pglite::Error> { + let count = db.scalar_text("SELECT count(*) FROM base_user").await?; + // 🔴 `count(*)` 恒有一行;万一查不到(None)也**不**种(宁可少种也不要重复 admin)。 + if count.as_deref() != Some("0") { + return Ok(()); + } + + let now = now_str(); + seed_admin_user(db, &now, admin_password).await?; + seed_admin_role_relation(db).await?; + Ok(()) +} + +// ---- 内置角色 ---- + +/// 补内置角色(按 `f_en_code` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 +async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> { + for role in BUILTIN_ROLES { + let id = role.id.to_string(); + let en_code = role.en_code.to_string(); + // 🔴 存在性判定 = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」。 + // 只按 en_code 判会出事:用户把内置角色的 `f_en_code` 改掉后, + // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ + // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 + // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」。 + let existing = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_role \ + WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1", + &[&en_code, &id], + ) + .await?; + if !existing.is_empty() { + continue; + } + + let full_name = role.full_name.to_string(); + let role_type = "user".to_string(); + let sort_code = role.sort_code.to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let params: [&(dyn ToSql + Sync); 10] = [ + &id, + &full_name, + &en_code, + &role_type, + &sort_code, + &enabled_mark, + &delete_mark, + &tenant_id, + &creator, + &now, + ]; + db.exec_params( + "INSERT INTO base_role \ + (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_enabled_mark, \ + f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ + $6::text::integer, $7::text::integer, $8::text, $9::text, \ + $10::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- 内置菜单 ---- + +/// 补内置菜单(按 `f_url_address` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 +/// +/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条(由 [`all_builtin_menus`] 拼好)。 +async fn ensure_builtin_menus( + db: &Db, + now: &str, + menus: &[MenuSpec], +) -> Result<(), pglite::Error> { + for menu in menus { + let id = menu.id.to_string(); + let url_address = menu.url_address.to_string(); + // 🔴 存在性判定 = 「`f_url_address` 命中 **或** `f_id` = 固定字面量」。 + // 只按 url 判会出事:用户把内置菜单的 `f_url_address` 改掉后, + // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ + // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 + // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」(契约 §8.6 明确要求)。 + let existing = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_module \ + WHERE f_url_address = $1::text OR f_id = $2::text LIMIT 1", + &[&url_address, &id], + ) + .await?; + if !existing.is_empty() { + // 🔴 **存量库回填 `f_en_code` / `f_system_id`**:本仓早期版本的种子**不写** + // 这两列 ⇒ 存量库全是 NULL ⇒ 面 B 点权限判据落空(全站放行),且菜单无法按系统隔离。 + // 只在 **NULL 时**回填 ⇒ 人工改过的值不会被覆盖。 + let existing_id = existing + .first() + .and_then(|r| r["id"].as_str()) + .unwrap_or(id.as_str()) + .to_string(); + let en_code = menu.en_code.to_string(); + let system_id = system_id_of(db, menu.system_en_code).await; + db.exec_params( + "UPDATE base_module SET f_en_code = $1::text, f_system_id = $2::text \ + WHERE f_id = $3::text AND (f_en_code IS NULL OR f_system_id IS NULL)", + &[&en_code, &system_id, &existing_id], + ) + .await?; + continue; + } + + let full_name = menu.full_name.to_string(); + let en_code = menu.en_code.to_string(); + let parent_id = menu.parent_id.to_string(); + let menu_type = menu.menu_type.to_string(); + // 🔴 图标为 `None` ⇒ 写 **NULL**(契约 §8.4 的 `—`,不是空串)。 + let icon = menu.icon.map(str::to_string); + let sort_code = menu.sort_code.to_string(); + // 🔴 菜单按所属应用落 `f_system_id`(多应用隔离的落点)。 + let system_id = system_id_of(db, menu.system_en_code).await; + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let params: [&(dyn ToSql + Sync); 14] = [ + &id, + &full_name, + &en_code, + &url_address, + &parent_id, + &menu_type, + &icon, + &sort_code, + &system_id, + &enabled_mark, + &delete_mark, + &tenant_id, + &creator, + &now, + ]; + db.exec_params( + "INSERT INTO base_module \ + (f_id, f_full_name, f_en_code, f_url_address, f_parent_id, f_type, f_icon, f_sort_code, \ + f_system_id, f_enabled_mark, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, $7::text, \ + $8::text::bigint, $9::text, $10::text::integer, $11::text::integer, $12::text, \ + $13::text, $14::text::timestamp)", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- admin 授权 ---- + +/// 补 admin 角色对内置菜单的授权(只补缺项)。 +/// +/// 契约 §8.6: +/// - admin 角色行取 `f_en_code='admin'` 的**真实**行(🔴 不按 `f_delete_mark` 过滤, +/// 可能是用户自建的行 ⇒ id 不等于 `role_admin`); +/// - 待授权的菜单 = `f_delete_mark=0` **且** `f_url_address` 命中内置清单的行; +/// - 「已授权」判定 = `base_authorize` 中 +/// `f_object_type='role' AND f_object_id= AND f_item_type='module'` +/// 的**全部行**(🔴 不按 `f_delete_mark` 过滤)。 +/// +/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条 ⇒ admin 角色对**全部内置菜单** +/// 都有授权(契约 §8.6:内置 8 条菜单 ⇒ admin 8 条授权)。 +async fn ensure_admin_authorizations( + db: &Db, + now: &str, + menus: &[MenuSpec], +) -> Result<(), pglite::Error> { + // ---- 1) 取 admin 角色的真实行 ---- + let en_code = ADMIN_ROLE_EN_CODE.to_string(); + // 🔴 用的是**查到的真实行**(可能是用户自建的行 ⇒ id 不等于 `role_admin`)。 + // `f_en_code` 没有 UNIQUE 约束(应用层保证唯一)⇒ 万一有多行,按 `f_id` 取 + // 最小的那条,保证结果**确定**(同库多次跑 ⇒ 同一个 id)。 + let admin_roles = db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_role WHERE f_en_code = $1::text \ + ORDER BY f_id LIMIT 1", + &[&en_code], + ) + .await?; + let Some(admin_role) = admin_roles.first() else { + // 没有 admin 角色 ⇒ 无从授权(`ensure_builtin_roles` 刚补过,除非被并发删了)。 + return Ok(()); + }; + let admin_role_id = admin_role["id"].as_str().unwrap_or_default().to_string(); + if admin_role_id.is_empty() { + return Ok(()); + } + + // ---- 2) 取内置菜单里「还活着」的行(f_delete_mark=0 且 url 命中清单)---- + let live_modules = db + .query_json( + "SELECT f_id AS \"id\", f_url_address AS \"urlAddress\" \ + FROM base_module WHERE f_delete_mark = 0", + ) + .await?; + let builtin_live: Vec = live_modules + .iter() + .filter(|row| { + row["urlAddress"] + .as_str() + .map(|url| menus.iter().any(|m| m.url_address == url)) + .unwrap_or(false) + }) + .filter_map(|row| row["id"].as_str().map(str::to_string)) + .collect(); + + // ---- 3) 取「已授权」的 f_item_id 集合 ---- + // + // 🔴 **不按 f_delete_mark 过滤** ⇒ 软删的授权行也算「已授权」⇒ 不补。 + let granted = db + .query_json_params( + "SELECT f_item_id AS \"itemId\" FROM base_authorize \ + WHERE f_object_type = 'role' AND f_object_id = $1::text \ + AND f_item_type = 'module'", + &[&admin_role_id], + ) + .await?; + let granted: Vec = granted + .iter() + .filter_map(|row| row["itemId"].as_str().map(str::to_string)) + .collect(); + + // ---- 4) 缺项 ⇒ 补一条授权 ---- + for menu_id in builtin_live { + if granted.iter().any(|g| g == &menu_id) { + continue; + } + let auth_id = new_uuid(); + let sort_code = "0".to_string(); + let delete_mark = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let params: [&(dyn ToSql + Sync); 7] = [ + &auth_id, + &admin_role_id, + &menu_id, + &sort_code, + &creator, + &now, + &delete_mark, + ]; + db.exec_params( + "INSERT INTO base_authorize \ + (f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, 'role', $2::text, 'module', $3::text, $4::text::bigint, \ + $5::text, $6::text::timestamp, $7::text::integer, '0')", + ¶ms, + ) + .await?; + } + Ok(()) +} + +// ---- 首启:admin 用户 + 角色关联 ---- + +/// 建 admin 用户(`f_password` = `md5_hex(admin_password)`)。 +/// +/// 🔴 `admin_password` 是**明文** ⇒ 立刻算 md5,**明文不进任何 SQL 参数、不进日志**。 +async fn seed_admin_user( + db: &Db, + now: &str, + admin_password: &str, +) -> Result<(), pglite::Error> { + let id = new_uuid(); + let account = ADMIN_ACCOUNT.to_string(); + let real_name = "管理员".to_string(); + let password = md5_hex(admin_password); + let is_administrator = "1".to_string(); + let organize_id = "0".to_string(); + let creator = ADMIN_ACCOUNT.to_string(); + let now = now.to_string(); + let enabled_mark = "1".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let params: [&(dyn ToSql + Sync); 11] = [ + &id, + &account, + &real_name, + &password, + &is_administrator, + &organize_id, + &creator, + &now, + &enabled_mark, + &delete_mark, + &tenant_id, + ]; + db.exec_params( + "INSERT INTO base_user \ + (f_id, f_account, f_real_name, f_password, f_is_administrator, f_organize_id, \ + f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ + $7::text, $8::text::timestamp, $9::text::integer, $10::text::integer, \ + $11::text)", + ¶ms, + ) + .await?; + Ok(()) +} + +/// 建 admin 的角色关联(`base_role_relation`)。 +/// +/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在 +/// `f_object_id`(配 `f_object_type='user'`);这里逐字用**账号名** `'admin'` +/// (react 源码里就是 `'admin'`,契约 §8.6 明确要求)。 +/// +/// 🔴 契约 §8.6 对这一行**逐字只列了 7 个字段**(`f_id` / `f_role_id` / `f_object_type` / +/// `f_object_id` / `f_sort_code` / `f_delete_mark` / `f_tenant_id`),**不含** +/// `f_creator_user_id` / `f_creator_time`(react 的 `roleRelRepo.save` 也不写这两列) +/// ⇒ 这里就**不写**(DDL 允许 NULL,不影响任何逻辑)。 +async fn seed_admin_role_relation(db: &Db) -> Result<(), pglite::Error> { + let id = new_uuid(); + let role_id = ADMIN_ROLE_ID.to_string(); + let object_type = "user".to_string(); + let object_id = ADMIN_ACCOUNT.to_string(); + let sort_code = "0".to_string(); + let delete_mark = "0".to_string(); + let tenant_id = "0".to_string(); + let params: [&(dyn ToSql + Sync); 7] = [ + &id, + &role_id, + &object_type, + &object_id, + &sort_code, + &delete_mark, + &tenant_id, + ]; + db.exec_params( + "INSERT INTO base_role_relation \ + (f_id, f_role_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, \ + f_tenant_id) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ + $6::text::integer, $7::text)", + ¶ms, + ) + .await?; + Ok(()) +} + +/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 +fn now_str() -> String { + chrono::Utc::now() + .naive_utc() + .format("%Y-%m-%d %H:%M:%S") + .to_string() +} diff --git a/crates/sspf-core/src/session.rs b/crates/sspf-core/src/session.rs new file mode 100644 index 0000000..37295ea --- /dev/null +++ b/crates/sspf-core/src/session.rs @@ -0,0 +1,451 @@ +//! session —— 内存 token 会话表(进程内,进程重启即失效)。 +//! +//! 契约:登录成功后签发 token,后续请求带 `Authorization: bearer ` 解析出用户。 +//! +//! 🔴 **不用 Redis / Sa-Token**:本仓 v1 就是内存 token 表(与 JNPF 的 Sa-Token 内存模式同代)。 +//! +//! 🔴 **锁用 `std::sync::RwLock`**:访问全是同步的、无 await ⇒ 用 tokio 的锁会逼 `issue`/`resolve` +//! 变成 async,改变契约里定死的签名。 + +use std::collections::HashMap; +use std::sync::{Arc, RwLock}; + +use rand::Rng; + +use crate::cipher::md5_hex; + +/// token 前缀(`"lite-"` + 32 个小写 hex ⇒ 总长 37)。 +const TOKEN_PREFIX: &str = "lite-"; + +/// `Authorization` 头里的 bearer 前缀(**含尾部空格**,共 7 字符)。 +const BEARER_PREFIX: &str = "bearer "; + +/// token 解析出来的用户信息。 +#[derive(Clone)] +pub struct TokenUser { + /// 用户主键(36 位 UUID v4)。 + pub user_id: String, + /// 登录账号。 + pub account: String, + /// 是否管理员(`base_user.f_is_administrator`,1 = 是)。 + pub is_admin: i32, + /// 签发时刻(毫秒时间戳,UTC)。在线用户页的「登录时间」来自这里。 + pub issued_at_ms: i64, + /// 登录 IP(取自 `X-Forwarded-For` / `X-Real-IP`;都没有 ⇒ 空串)。 + pub ip: String, + /// 登录 UA(原样保留,浏览器名由 `face_b` 现推)。 + pub user_agent: String, +} + +/// 内存 token 表:`token -> TokenUser`。 +#[derive(Clone, Default)] +pub struct SessionStore { + /// 🔴 放在 `Arc` 里:多个 handler 共享同一张表。 + inner: Arc>>, +} + +impl SessionStore { + /// 建一张空表。 + pub fn new() -> Self { + Self { + inner: Arc::new(RwLock::new(HashMap::new())), + } + } + + /// 签发一个 token,返回值形状 = `"lite-" + 32 个小写 hex`(总长 37)。 + /// + /// token = `"lite-" + md5(account + 毫秒时间戳 + 随机数)`。 + pub fn issue(&self, account: &str, user_id: &str, is_admin: i32) -> String { + self.issue_with_meta(account, user_id, is_admin, "", "") + } + + /// 同上,但一并记下**登录时的 IP 与 UA**(在线用户页要用)。 + /// + /// 🔴 分成两个方法而不是改 `issue` 的签名:`issue` 有十几个测试与夹具在用, + /// 为了「多记两列」把它们全改一遍不划算,也容易漏。 + pub fn issue_with_meta( + &self, + account: &str, + user_id: &str, + is_admin: i32, + ip: &str, + user_agent: &str, + ) -> String { + let millis = chrono::Utc::now().timestamp_millis(); + let rand: u64 = rand::thread_rng().gen(); + let digest = md5_hex(&format!("{}{}{}", account, millis, rand)); + + let token = format!("{}{}", TOKEN_PREFIX, digest); + let user = TokenUser { + user_id: user_id.to_string(), + account: account.to_string(), + is_admin, + issued_at_ms: millis, + ip: ip.to_string(), + user_agent: user_agent.to_string(), + }; + if let Ok(mut map) = self.inner.write() { + map.insert(token.clone(), user); + } + token + } + + /// 从 `Authorization` 头解析出用户。 + /// + /// - `None` / 空串 ⇒ `None`; + /// - 前 7 个字符大小写不敏感地命中 `"bearer "` ⇒ 截掉这 7 个字符查表; + /// - **不命中 ⇒ 整串当裸 token 查表**(有些客户端直接发裸 token); + /// - 查不到 ⇒ `None`。 + pub fn resolve(&self, auth_header: Option<&str>) -> Option { + let header = auth_header?.trim(); + if header.is_empty() { + return None; + } + + // 🔴 先看**前 7 个字节**:命中才截掉,否则整串当 token(大小写不敏感)。 + let bytes = header.as_bytes(); + let token = if bytes.len() >= BEARER_PREFIX.len() + && bytes[..BEARER_PREFIX.len()].eq_ignore_ascii_case(BEARER_PREFIX.as_bytes()) + { + &header[BEARER_PREFIX.len()..] + } else { + header + }; + if token.is_empty() { + return None; + } + + let map = self.inner.read().ok()?; + map.get(token).cloned() + } + + /// 全部会话的快照 `[(token, 用户)]`。 + /// + /// 🔴 **只在进程内用,别把 `token` 序列化给前端** —— 缓存管理页只用它算 + /// 「谁在线 / 有几条会话 / 占多少字节」,对外一律按**账号**聚合 + /// (见 `face_b.rs` 的 `cache_manage_list`)。 + pub fn snapshot(&self) -> Vec<(String, TokenUser)> { + match self.inner.read() { + Ok(map) => map.iter().map(|(k, v)| (k.clone(), v.clone())).collect(), + Err(_) => Vec::new(), + } + } + + /// 注销某账号的**全部**会话(「踢下线」),返回删掉的条数。 + pub fn revoke_account(&self, account: &str) -> usize { + match self.inner.write() { + Ok(mut map) => { + let before = map.len(); + map.retain(|_, u| u.account != account); + before - map.len() + } + Err(_) => 0, + } + } + + /// 注销**除某账号外**的全部会话,返回删掉的条数。 + /// + /// 对齐官方 `CacheManageController.clearAll` 的「跳过 token 前缀的键」—— + /// 清空缓存不该把自己这一条也清掉(否则点一下就被踢回登录页)。 + pub fn revoke_except(&self, account: &str) -> usize { + match self.inner.write() { + Ok(mut map) => { + let before = map.len(); + map.retain(|_, u| u.account == account); + before - map.len() + } + Err(_) => 0, + } + } + + /// 给**已签发**的会话补记登录元信息(IP / UA),返回是否命中。 + /// + /// 🔴 为什么不在 `issue` 时就传:`login_from_bytes` 有十几个测试在用, + /// 改它的签名要动一片;而登录 handler 拿到 token 之后再回调一次最省事, + /// **只影响真实 HTTP 路径**(测试直接调 `login_from_bytes` 的就只有空元信息)。 + pub fn annotate(&self, token: &str, ip: &str, user_agent: &str) -> bool { + match self.inner.write() { + Ok(mut map) => match map.get_mut(token) { + Some(user) => { + user.ip = ip.to_string(); + user.user_agent = user_agent.to_string(); + true + } + None => false, + }, + Err(_) => false, + } + } + + /// 按**会话指纹**注销单条会话,返回是否真的删掉了一条。 + pub fn revoke_by_fingerprint(&self, fingerprint: &str) -> bool { + let target = fingerprint.trim().to_lowercase(); + if target.is_empty() { + return false; + } + match self.inner.write() { + Ok(mut map) => { + let hit = map + .keys() + .find(|token| fingerprint_of(token) == target) + .cloned(); + match hit { + Some(token) => map.remove(&token).is_some(), + None => false, + } + } + Err(_) => false, + } + } + + /// 注销这些**用户主键**名下的全部会话(角色变更后「踢下线」用),返回删掉的条数。 + pub fn revoke_user_ids(&self, ids: &[String]) -> usize { + if ids.is_empty() { + return 0; + } + match self.inner.write() { + Ok(mut map) => { + let before = map.len(); + map.retain(|_, u| !ids.iter().any(|id| id == &u.user_id)); + before - map.len() + } + Err(_) => 0, + } + } +} + +/// 会话**指纹**:`md5(token)` 的 32 位小写 hex。 +/// +/// 🔴 **在线用户页对外只给指纹,绝不给真 token**:官方把 Sa-Token 的 token 当 +/// 「在线用户 id」直接返回(`UserOnlineController.java:58` `vo.setUserId(online.getToken())`), +/// 而管理员能看到**所有人**的 token ⇒ 等于能冒充任何人。指纹是单向的, +/// 前端拿它回传 `DELETE /{fingerprint}` 照样能精确踢人。 +pub fn fingerprint_of(token: &str) -> String { + md5_hex(token) +} + +// ================================================================ 票据(ticket) +// +// 🔴 **官方出处**:`LoginController.java:383`(`getTicket`)/ `:398`(`getTicketStatus`) +// / `:454`(`codeCertificate`)/ `:468`(`codeCertificateStatus`) +// / `:507`(`setCodeCertificateStatus`)。 +// +// 🔴 **官方用 Redis 存票据**(`TicketUtil.createTicket` / `parseTicket` / `updateTicket`) +// ⇒ 本仓**无 Redis** ⇒ 照 `SessionStore` 的同款做法:**进程内内存表** +// (进程重启即失效 —— 与本仓 token 表同一口径,不假装能跨重启)。 +// +// 🔴 **为什么不塞进 token 表**:票据载荷(状态 / 超时 / 值)与 token(用户身份) +// 生命周期与语义都不同 ⇒ 混在一张表里会让「注销会话」误删票据。 + +/// 票据的**种类**。 +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub enum TicketKind { + /// 免密登录票据(`getTicket` / `getTicketStatus`)。 + Login, + /// 扫码登录凭证(`codeCertificate` / `codeCertificateStatus` / `setCodeCertificateStatus`)。 + ScanCode, +} + +impl TicketKind { + /// 票据串前缀 —— 两种票据**不能互相串用**(官方也是两张不同的 Redis key)。 + fn prefix(&self) -> &'static str { + match self { + TicketKind::Login => "tkt-", + TicketKind::ScanCode => "scc-", + } + } +} + +/// 一张票据的内容。 +#[derive(Clone, Debug)] +pub struct Ticket { + /// 票据种类。 + pub kind: TicketKind, + /// 状态码(官方 `LoginTicketStatus` / `ScanCodeTicketStatus` 的整数值)。 + pub status: i32, + /// 附带值(官方 `LoginTicketModel.value` —— 扫码确认后放登录 token)。 + pub value: String, + /// 主题(官方 `LoginTicketModel.theme`)。 + pub theme: String, + /// 过期时刻(毫秒时间戳,UTC)—— 对应官方 `ticketTimeout`。 + pub expires_at_ms: i64, +} + +impl Ticket { + /// 是否已过期。 + pub fn is_expired(&self, now_ms: i64) -> bool { + now_ms >= self.expires_at_ms + } +} + +/// 内存票据表:`票据串 -> Ticket`。 +#[derive(Clone, Default)] +pub struct TicketStore { + inner: Arc>>, +} + +impl TicketStore { + /// 建一张空表。 + pub fn new() -> Self { + Self { + inner: Arc::new(RwLock::new(HashMap::new())), + } + } + + /// 签发票据,返回票据串。 + /// + /// 🔴 票据串 = 前缀 + `md5(种类 + 毫秒时间戳 + 随机数)`(与 token 同一套手法)。 + pub fn issue(&self, kind: TicketKind, status: i32, ttl_seconds: i64) -> (String, i64) { + let now_ms = chrono::Utc::now().timestamp_millis(); + let rand: u64 = rand::thread_rng().gen(); + let digest = md5_hex(&format!("{:?}{}{}", kind, now_ms, rand)); + let ticket = format!("{}{}", kind.prefix(), digest); + let expires_at_ms = now_ms + ttl_seconds * 1000; + if let Ok(mut map) = self.inner.write() { + map.insert( + ticket.clone(), + Ticket { + kind, + status, + value: String::new(), + theme: String::new(), + expires_at_ms, + }, + ); + } + (ticket, expires_at_ms) + } + + /// 读票据;**过期即删**(官方 `parseTicket` 同样会判超时)。 + pub fn get(&self, kind: TicketKind, ticket: &str) -> Option { + let ticket = ticket.trim(); + if ticket.is_empty() { + return None; + } + let now_ms = chrono::Utc::now().timestamp_millis(); + let map = self.inner.read().ok()?; + let found = map.get(ticket).cloned()?; + // 🔴 种类不符 ⇒ 当作不存在(两种票据不能串用)。 + if found.kind != kind { + return None; + } + if found.is_expired(now_ms) { + drop(map); + self.remove(ticket); + return None; + } + Some(found) + } + + /// 更新票据的**状态 / 值**(官方 `TicketUtil.updateTicket`)。 + pub fn update(&self, kind: TicketKind, ticket: &str, status: i32, value: &str, ttl_seconds: i64) -> Option { + let ticket = ticket.trim(); + if ticket.is_empty() { + return None; + } + let now_ms = chrono::Utc::now().timestamp_millis(); + let mut map = self.inner.write().ok()?; + let entry = map.get_mut(ticket)?; + if entry.kind != kind { + return None; + } + entry.status = status; + if !value.is_empty() { + entry.value = value.to_string(); + } + entry.expires_at_ms = now_ms + ttl_seconds * 1000; + Some(entry.clone()) + } + + /// 删一张票据(官方 `TicketUtil.deleteTicket`)。 + pub fn remove(&self, ticket: &str) -> bool { + match self.inner.write() { + Ok(mut map) => map.remove(ticket.trim()).is_some(), + Err(_) => false, + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// token 形状:`"lite-"` 前缀 + 32 个小写 hex ⇒ 总长 37。 + #[test] + fn issued_token_shape() { + let store = SessionStore::new(); + let token = store.issue("admin", "uid-1", 1); + assert!(token.starts_with(TOKEN_PREFIX), "前缀必须是 lite-:{token}"); + let hex = &token[TOKEN_PREFIX.len()..]; + assert_eq!(hex.len(), 32, "必须是 32 个 hex 字符:{token}"); + assert_eq!(token.len(), 37, "总长必须是 37:{token}"); + assert!( + hex.chars().all(|c| c.is_ascii_digit() || ('a'..='f').contains(&c)), + "必须是小写 hex:{token}" + ); + } + + /// 签发后用 `bearer ` 能解析出正确的用户信息。 + #[test] + fn resolve_with_bearer_prefix() { + let store = SessionStore::new(); + let token = store.issue("zhangsan", "uid-abc", 0); + let got = store.resolve(Some(&format!("bearer {}", token))); + let user = got.expect("bearer 前缀必须能解析"); + assert_eq!(user.account, "zhangsan"); + assert_eq!(user.user_id, "uid-abc"); + assert_eq!(user.is_admin, 0); + } + + /// 前缀大小写不敏感(`BEARER` / `BeArEr` 都行)。 + #[test] + fn resolve_prefix_is_case_insensitive() { + let store = SessionStore::new(); + let token = store.issue("lisi", "uid-def", 1); + for prefix in ["BEARER ", "Bearer ", "beArEr "] { + let got = store.resolve(Some(&format!("{}{}", prefix, token))); + let user = got.unwrap_or_else(|| panic!("前缀 {} 必须能解析", prefix)); + assert_eq!(user.account, "lisi"); + assert_eq!(user.user_id, "uid-def"); + assert_eq!(user.is_admin, 1); + } + } + + /// 裸 token(不带前缀)也能解析。 + #[test] + fn resolve_bare_token() { + let store = SessionStore::new(); + let token = store.issue("wangwu", "uid-ghi", 0); + let got = store.resolve(Some(&token)); + assert_eq!(got.map(|u| u.account), Some("wangwu".to_string())); + } + + /// `None` / 空串 / 查不到的 token ⇒ `None`。 + #[test] + fn resolve_rejects_invalid() { + let store = SessionStore::new(); + assert!(store.resolve(None).is_none()); + assert!(store.resolve(Some("")).is_none()); + assert!(store.resolve(Some("bearer nope")).is_none()); + assert!(store.resolve(Some("nope")).is_none()); + } + + /// 两个不同签发的 token 互不干扰。 + #[test] + fn distinct_tokens_do_not_interfere() { + let store = SessionStore::new(); + let t1 = store.issue("u1", "id-1", 0); + let t2 = store.issue("u2", "id-2", 1); + assert_ne!(t1, t2, "两次签发不得相同"); + assert_eq!(store.resolve(Some(&t1)).map(|u| u.account), Some("u1".to_string())); + assert_eq!(store.resolve(Some(&t2)).map(|u| u.account), Some("u2".to_string())); + assert_eq!(store.resolve(Some(&t2)).map(|u| u.is_admin), Some(1)); + } + + /// `Default` 与 `new()` 等价(都能当空表用)。 + #[test] + fn default_is_empty_store() { + let store = SessionStore::default(); + assert!(store.resolve(Some("lite-whatever")).is_none()); + } +} diff --git a/crates/sspf-core/src/state.rs b/crates/sspf-core/src/state.rs new file mode 100644 index 0000000..e2df5d7 --- /dev/null +++ b/crates/sspf-core/src/state.rs @@ -0,0 +1,44 @@ +//! state —— 全局应用状态(axum `Router` 的 `State`)。 +//! +//! 契约:规格 §9「AppState」。 +//! +//! 🔴 `config` 必须装在 `Arc` 里(`Config` 每次克隆都要复制 `PathBuf`), +//! 🔴 `db` 按契约写死 `Arc`(虽然 `Db` 本身是 `Clone`,但契约形状不改)。 +//! 🔴 `sessions` 用 `Arc` ⇒ 多 handler 共享同一张 token 表。 + +use std::sync::Arc; + +use crate::config::Config; +use crate::db::Db; +use crate::session::{SessionStore, TicketStore}; + +/// 全局应用状态。 +#[derive(Clone)] +pub struct AppState { + /// 运行时配置(端口 / 数据目录 / 静态目录)。 + pub config: Arc, + /// pglite 封装。 + pub db: Arc, + /// 内存 token 会话表。 + pub sessions: Arc, + /// 🔴 内存票据表(免密登录票据 / 扫码凭证)。 + /// + /// 🔴 **官方出处**:`LoginController.java:383`(`getTicket`)/ `:398` + /// (`getTicketStatus`)/ `:454`(`codeCertificate`)/ `:468` + /// (`codeCertificateStatus`)/ `:507`(`setCodeCertificateStatus`)。 + /// 官方用 Redis 存 ⇒ 本仓无 Redis ⇒ 照 token 表的同款做法用**进程内内存表** + /// (进程重启即失效,不假装能跨重启)。 + pub tickets: Arc, +} + +#[cfg(test)] +mod tests { + use super::*; + + /// axum `State` 要求 `Clone + Send + Sync + 'static` —— 编译期钉住。 + #[test] + fn app_state_satisfies_axum_state_bounds() { + fn assert_state_bounds() {} + assert_state_bounds::(); + } +} diff --git a/crates/sspf-core/src/sys.rs b/crates/sspf-core/src/sys.rs new file mode 100644 index 0000000..9f245fb --- /dev/null +++ b/crates/sspf-core/src/sys.rs @@ -0,0 +1,1295 @@ +//! sys —— 5 组 `base_*` CRUD(User / Role / Organize / Module)+ 授权写入。 +//! +//! 契约:`docs/contract.md` §6.2 / §6.3(端点)+ §7.1–§7.5(语义)+ §7.7(唯一刻意偏离)。 +//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/sys/sys.service.ts` +//! 与 `.../sys/authorize.controller.ts`。 +//! +//! 🔴 **七条硬约定**: +//! 1. **业务失败恒 HTTP 200**(信封里的 `code=400`);DB 报错 ⇒ `系统异常,请联系管理员` +//! (真因只进服务端日志,**不外泄**)。 +//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 +//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `realname` ⇒ 前端读不到,且**静默**)。 +//! 3. **口令不得外泄**:`base_user` 的读回投影**根本不选 `f_password`** +//! (比「选了再删」更安全)⇒ List / Save 响应里**没有 `password` 键**。 +//! 4. **标识符白名单 + 参数化**:动态拼的表名/列名先过 `db::valid_table` / `db::valid_column`; +//! **所有用户数据**走绑定参数,绝不拼进 SQL 文本。 +//! 5. **只 SET body 里出现的键**(react / TypeORM `save` 的 `undefined` 语义,裁决 S16)。 +//! 🔴 这条保护 `base_module.f_url_address`(权限守卫的比对键)不被误清成 NULL。 +//! 6. **多步写用 data-modifying CTE 合成一条语句**(裁决 P59)⇒ 一条语句 = 一个隐式事务 = 原子。 +//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 + +use std::collections::HashMap; + +use axum::body::Bytes; +use axum::extract::{Path, RawQuery, State}; +use axum::http::HeaderMap; +use axum::Json; +use serde_json::{json, Map, Value}; + +use crate::auth::{require_login, require_login_any, require_module}; +use crate::cipher::md5_hex; +use crate::db::{self, pglite, pglite::ToSql, Db}; +use crate::envelope::{fail, ok, ActionResult}; +use crate::ids::new_uuid; +use crate::state::AppState; + +// ---------------------------------------------------------------- 菜单守卫 key + +const USER_MODULE: &str = "system/User"; +const ROLE_MODULE: &str = "system/Role"; +const ORGANIZE_MODULE: &str = "system/Organize"; +const MODULE_MODULE: &str = "system/Module"; + +// ---------------------------------------------------------------- 投影列(契约 §5.3) + +/// `base_user` 的读回投影(12 列)—— 🔴 **不含 `f_password`**(R1.6:根本不选它)。 +const USER_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_account AS "account", +f_real_name AS "realName", f_secretkey AS "secretkey", +f_is_administrator AS "isAdministrator", f_role_id AS "roleId", +f_organize_id AS "organizeId", f_creator_user_id AS "creatorUserId", +to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", +f_enabled_mark AS "enabledMark", f_delete_mark AS "deleteMark""#; + +/// `base_role` 的读回投影(11 列)。 +const ROLE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", +f_en_code AS "enCode", f_type AS "type", f_description AS "description", +f_enabled_mark AS "enabledMark", f_sort_code AS "sortCode", +f_creator_user_id AS "creatorUserId", +to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", +f_delete_mark AS "deleteMark""#; + +/// `base_organize` 的读回投影(11 列)—— 🔴 **没有 `f_creator_user_id`**。 +const ORGANIZE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", +f_parent_id AS "parentId", f_category AS "category", f_en_code AS "enCode", +f_manager_id AS "managerId", f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", +to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", +f_delete_mark AS "deleteMark""#; + +/// `base_module` 的读回投影(13 列)—— 🔴 **没有 `f_creator_user_id`**。 +const MODULE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", +f_url_address AS "urlAddress", f_parent_id AS "parentId", f_type AS "type", +f_category AS "category", f_en_code AS "enCode", f_icon AS "icon", +f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", +to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", +f_delete_mark AS "deleteMark""#; + +// ---------------------------------------------------------------- 通用小工具 + +/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 +fn db_error(e: pglite::Error, ctx: &str) -> Json { + eprintln!("[sys] {ctx}失败: {e}"); + fail(400, "系统异常,请联系管理员") +} + +/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 +fn now_str() -> String { + chrono::Utc::now() + .naive_utc() + .format("%Y-%m-%d %H:%M:%S") + .to_string() +} + +/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 +/// +/// 🔴 **不用 axum 的 `Json`**:它的解析失败会返回 **422 + 非信封 body** ⇒ 契约破。 +fn parse_body(body: &Bytes) -> Result> { + match serde_json::from_slice::(body) { + Ok(v) => Ok(v), + Err(_) => Err(fail(400, "请求参数格式错误")), + } +} + +/// 取 body 里的对象;**不是对象 ⇒ 空对象**(⇒ 走「参数缺失」的业务文案分支)。 +fn body_object(body: &Bytes) -> Result, Json> { + let v = parse_body(body)?; + Ok(match v { + Value::Object(m) => m, + _ => Map::new(), + }) +} + +/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 +/// +/// 🔴 **不用 axum 的 `Query`**:它的解析失败会返回 **400 + 非信封 body** ⇒ 契约破。 +/// +/// 🔴 `pub(crate)` —— 面 B 的 `face_b` 模块也要用它(官方分页参数 `currentPage` / `pageSize`)。 +pub fn query_param(raw: &RawQuery, key: &str) -> String { + let Some(q) = raw.0.as_deref() else { + return String::new(); + }; + let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); + pairs + .into_iter() + .find(|(k, _)| k == key) + .map(|(_, v)| v) + .unwrap_or_default() +} + +/// JS 真值判定(react 的 `dto.isAdministrator ? 1 : 0`)。 +fn truthy(v: Option<&Value>) -> bool { + match v { + None | Some(Value::Null) => false, + Some(Value::Bool(b)) => *b, + Some(Value::Number(n)) => n.as_f64().map(|f| f != 0.0).unwrap_or(false), + Some(Value::String(s)) => !s.is_empty(), + Some(Value::Array(a)) => !a.is_empty(), + Some(Value::Object(o)) => !o.is_empty(), + } +} + +/// `body.organizeId || '0'` / `body.parentId || '0'` 的 JS `||` 语义。 +fn or_zero(v: Option<&Value>) -> String { + match v { + Some(Value::String(s)) if !s.is_empty() => s.clone(), + _ => "0".to_string(), + } +} + +/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 +fn value_to_text(v: Option<&Value>) -> Option { + match v { + Some(Value::String(s)) => Some(s.clone()), + Some(Value::Number(n)) => Some(n.to_string()), + Some(Value::Bool(b)) => Some(b.to_string()), + _ => None, + } +} + +/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 +/// +/// 🔴 键存在且非 null、但**不是字符串**(如数字 `123`)⇒ **也算「有 id」**—— +/// react 的 `if (dto.id)` 对数字是 truthy ⇒ 走更新分支;按其 JSON 文本去查, +/// 查不到 ⇒ `400 '用户不存在'`(**不是**新建一行)。 +/// 空串 ⇒ 视作**无 id**(react 的 `if ('')` 是 falsy)。 +fn body_id(obj: &Map) -> Option { + match obj.get("id") { + None | Some(Value::Null) => None, + Some(Value::String(s)) if s.is_empty() => None, + Some(Value::String(s)) => Some(s.clone()), + Some(other) => Some(other.to_string()), + } +} + +/// body 里取一个整数(`null` / 不可解析 ⇒ `None`)。 +fn value_to_i64(v: Option<&Value>) -> Option { + match v { + Some(Value::Number(n)) => n.as_i64().or_else(|| n.as_f64().map(|f| f as i64)), + Some(Value::String(s)) => s.trim().parse::().ok(), + _ => None, + } +} + +/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 +/// +/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 +fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { + values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() +} + +/// 一条待写入的字段。 +struct Field { + /// 目标列(**内部常量**,拼进 SQL 前仍要过白名单)。 + column: &'static str, + /// 追加在 `::text` 之后的类型转换(`""` / `"::integer"` / `"::bigint"`)。 + cast: &'static str, + /// 值(`None` ⇒ NULL)。 + value: Option, +} + +/// 构造 `UPDATE SET ... WHERE f_id = $n::text`。 +/// +/// 🔴 表名 / 列名都过白名单(红线 R1.10);**值全部走绑定参数**。 +fn build_update( + table: &str, + id: &str, + fields: &[Field], +) -> Result<(String, Vec>), pglite::Error> { + let table = db::valid_table(table) + .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; + let mut values: Vec> = Vec::new(); + let mut assigns: Vec = Vec::new(); + for f in fields { + // 🔴 白名单不过 ⇒ **不拼进 SQL**(宁可少更新一列,也不让用户 body 里的键进 SQL 文本)。 + let Some(col) = db::valid_column(f.column) else { + continue; + }; + values.push(f.value.clone()); + assigns.push(format!("{} = ${}::text{}", col, values.len(), f.cast)); + } + if assigns.is_empty() { + return Err(pglite::Error::Protocol("没有可更新的字段".to_string())); + } + values.push(Some(id.to_string())); + let sql = format!( + "UPDATE {} SET {} WHERE f_id = ${}::text", + table, + assigns.join(", "), + values.len() + ); + Ok((sql, values)) +} + +/// 按 id 读回一行(`None` ⇒ 没有这行)。 +async fn fetch_by_id( + db: &Db, + table: &str, + columns: &str, + id: &str, +) -> Result, pglite::Error> { + let table = db::valid_table(table) + .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; + let sql = format!("SELECT {columns} FROM {table} WHERE f_id = $1::text LIMIT 1"); + let rows = db.query_json_params(&sql, &[&id]).await?; + Ok(rows.into_iter().next()) +} + +/// 用户的 `roleIds` / `roleNames`(一次性把关系表与角色表各查一遍,避免 N+1)。 +/// +/// 🔴 `base_role_relation` **不过滤 `f_delete_mark`**(照抄 react 的 `roleRelRepo.find`)。 +/// 🔴 `roleNames` 查不到就**跳过**(不是空串、不是 null)⇒ 长度可能小于 `roleIds`。 +async fn user_role_map( + db: &Db, +) -> Result, Vec)>, pglite::Error> { + let rels = db + .query_json( + "SELECT f_object_id AS \"objectId\", f_role_id AS \"roleId\" \ + FROM base_role_relation WHERE f_object_type = 'user'", + ) + .await?; + let roles = db + .query_json( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\" FROM base_role \ + WHERE f_delete_mark = 0", + ) + .await?; + let mut names: HashMap = HashMap::new(); + for r in &roles { + let (Some(id), Some(name)) = ( + r.get("id").and_then(Value::as_str), + r.get("fullName").and_then(Value::as_str), + ) else { + continue; + }; + names.insert(id.to_string(), name.to_string()); + } + + let mut map: HashMap, Vec)> = HashMap::new(); + for rel in &rels { + let (Some(object_id), Some(role_id)) = ( + rel.get("objectId").and_then(Value::as_str), + rel.get("roleId").and_then(Value::as_str), + ) else { + continue; + }; + let entry = map.entry(object_id.to_string()).or_default(); + entry.0.push(role_id.to_string()); + } + // `roleNames` 按 `roleIds` 的顺序取,查不到就跳过。 + for (role_ids, role_names) in map.values_mut() { + for rid in role_ids.iter() { + if let Some(name) = names.get(rid) { + role_names.push(name.clone()); + } + } + } + Ok(map) +} + +// ---------------------------------------------------------------- User + +/// `GET /api/ssw/sys/User/List`(契约 §6.2 / §7.1)。 +pub async fn user_list(State(state): State, headers: HeaderMap) -> Json { + if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { + return resp; + } + let sql = format!( + "SELECT {USER_COLUMNS} FROM base_user WHERE f_delete_mark = 0 \ + ORDER BY f_creator_time DESC" + ); + let rows = match state.db.query_json(&sql).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "用户列表查询"), + }; + let role_map = match user_role_map(&state.db).await { + Ok(m) => m, + Err(e) => return db_error(e, "用户角色关系查询"), + }; + + let mut out: Vec = Vec::with_capacity(rows.len()); + for row in rows { + let Some(obj) = row.as_object() else { + continue; + }; + let id = obj.get("id").and_then(Value::as_str).unwrap_or_default(); + let (role_ids, role_names) = role_map.get(id).cloned().unwrap_or_default(); + let mut item = obj.clone(); + // 🔴 响应里**没有 `password` 键**(投影里根本没选 `f_password`)。 + item.insert("roleIds".to_string(), json!(role_ids)); + item.insert("roleNames".to_string(), json!(role_names)); + out.push(Value::Object(item)); + } + ok(Value::Array(out)) +} + +/// `POST /api/ssw/sys/User/Save`(契约 §7.1)。 +pub async fn user_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { + return resp; + } + let obj = match body_object(&body) { + Ok(o) => o, + Err(resp) => return resp, + }; + + // ---- 1) 账号必填 ---- + let account = obj.get("account").and_then(Value::as_str).unwrap_or(""); + if account.is_empty() { + return fail(400, "账号不能为空"); + } + let account = account.to_string(); + + // ---- 2) 查重(新建 / 更新**都查**):只比 `f_delete_mark = 0` 的行 ---- + // 🔴 官方 DDL 对 `f_account` **无 UNIQUE** ⇒ 唯一性只在应用层。 + let dup = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_user \ + WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", + &[&account], + ) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r.get("id")) + .and_then(Value::as_str) + .map(str::to_string), + Err(e) => return db_error(e, "用户查重"), + }; + + let id = body_id(&obj); + + match id { + // ---- 新建 ---- + None => { + if dup.is_some() { + return fail(400, format!("账号已存在:{account}")); + } + let new_id = new_uuid(); + let real_name = value_to_text(obj.get("realName")); + // 🔴 body 没有 password ⇒ `md5('123456')`(react 的默认口令)。 + let password = match obj.get("password").and_then(Value::as_str) { + Some(p) if !p.is_empty() => md5_hex(p), + _ => md5_hex("123456"), + }; + let is_admin = if truthy(obj.get("isAdministrator")) { + "1" + } else { + "0" + }; + let organize_id = or_zero(obj.get("organizeId")); + let now = now_str(); + let values: Vec> = vec![ + Some(new_id.clone()), + Some("0".to_string()), + Some(account.clone()), + real_name, + Some(password), + Some(is_admin.to_string()), + Some(organize_id), + Some("admin".to_string()), + Some(now), + Some("1".to_string()), + Some("0".to_string()), + ]; + let sql = "INSERT INTO base_user \ + (f_id, f_tenant_id, f_account, f_real_name, f_password, f_is_administrator, \ + f_organize_id, f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ + $7::text, $8::text, $9::text::timestamp, $10::text::integer, \ + $11::text::integer)"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "新建用户"); + } + if let Err(e) = write_user_roles(&state, &new_id, &obj).await { + return db_error(e, "用户角色关联写入"); + } + user_payload(&state, &new_id).await + } + // ---- 更新 ---- + Some(user_id) => { + // 🔴 按 `f_id` 查,**不按 `f_delete_mark` 过滤** ⇒ 软删过的行也算存在。 + let exists = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, &user_id).await { + Ok(v) => v.is_some(), + Err(e) => return db_error(e, "用户查询"), + }; + if !exists { + return fail(400, "用户不存在"); + } + // 🔴 dup 存在**且**不是自己 ⇒ 账号已被占用。 + if let Some(dup_id) = &dup { + if dup_id != &user_id { + return fail(400, format!("账号已存在:{account}")); + } + } + + let mut fields: Vec = Vec::new(); + // `f_account` 必覆盖(body 里 account 必填)。 + fields.push(Field { + column: "f_account", + cast: "", + value: Some(account.clone()), + }); + // `f_real_name`:**body 有才覆盖**(裁决 S16)。 + if obj.contains_key("realName") { + fields.push(Field { + column: "f_real_name", + cast: "", + value: value_to_text(obj.get("realName")), + }); + } + // `f_is_administrator`:**总是**覆盖为 body 真值 ? 1 : 0。 + fields.push(Field { + column: "f_is_administrator", + cast: "::integer", + value: Some( + if truthy(obj.get("isAdministrator")) { + "1" + } else { + "0" + } + .to_string(), + ), + }); + // `f_organize_id`:**总是**覆盖为 `body.organizeId || '0'`。 + fields.push(Field { + column: "f_organize_id", + cast: "", + value: Some(or_zero(obj.get("organizeId"))), + }); + // `f_password`:**body.password 非空才**覆盖。 + if let Some(p) = obj.get("password").and_then(Value::as_str) { + if !p.is_empty() { + fields.push(Field { + column: "f_password", + cast: "", + value: Some(md5_hex(p)), + }); + } + } + // ⚠️ 更新**不**碰 `f_creator_time` / `f_enabled_mark` / `f_delete_mark`。 + let (sql, values) = match build_update("base_user", &user_id, &fields) { + Ok(v) => v, + Err(e) => return db_error(e, "构造用户更新语句"), + }; + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "更新用户"); + } + if let Err(e) = write_user_roles(&state, &user_id, &obj).await { + return db_error(e, "用户角色关联写入"); + } + user_payload(&state, &user_id).await + } + } +} + +/// `DELETE /api/ssw/sys/User/Delete?id=`(契约 §7.1)。 +/// +/// 🔴 **不检查用户是否存在** ⇒ 不存在也返回成功(幂等)。 +pub async fn user_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { + return resp; + } + let id = query_param(&raw, "id"); + // 软删用户 + 硬删角色关联 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 + let sql = "WITH d AS (UPDATE base_user SET f_delete_mark = 1 WHERE f_id = $1::text) \ + DELETE FROM base_role_relation \ + WHERE f_object_type = 'user' AND f_object_id = $1::text"; + if let Err(e) = state.db.exec_params(sql, &[&id]).await { + return db_error(e, "删除用户"); + } + ok(Value::Null) +} + +/// 写用户的角色关联:`roleIds` 是数组 ⇒ **先硬删旧行再插新行**(契约 §7.1 第 5 条)。 +/// +/// 🔴 `roleIds` **不是数组**(缺省 / 类型不对)⇒ **不动**已有关系(react 的 +/// `Array.isArray(dto.roleIds)` 判定)。 +/// +/// 🔴 **DB 错误必须往上抛**(不吞)—— 吞掉的话角色授权根本没生效,响应却还是 +/// `code=200 / 成功` ⇒ 调用方拿到的信封与库里的事实不符。 +async fn write_user_roles( + state: &AppState, + user_id: &str, + obj: &Map, +) -> Result<(), pglite::Error> { + let Some(Value::Array(items)) = obj.get("roleIds") else { + return Ok(()); + }; + let role_ids: Vec = items + .iter() + .filter_map(|v| v.as_str()) + .filter(|s| !s.is_empty()) + .map(str::to_string) + .collect(); + + // 🔴 原始数组非空、但过滤后一个合法 id 都没有 ⇒ 这是**非法输入**, + // 不是「清空角色」。⇒ **不动**已有关系行(不要硬删)。 + if !items.is_empty() && role_ids.is_empty() { + return Ok(()); + } + + let mut values: Vec> = vec![Some(user_id.to_string())]; + let sql = if role_ids.is_empty() { + // 空数组 ⇒ 只删不插。 + "DELETE FROM base_role_relation WHERE f_object_type = 'user' AND f_object_id = $1::text" + .to_string() + } else { + let mut rows: Vec = Vec::new(); + for rid in &role_ids { + values.push(Some(new_uuid())); + values.push(Some(rid.clone())); + rows.push(format!( + "(${}::text, ${}::text)", + values.len() - 1, + values.len() + )); + } + // 硬删旧行 + 插新行 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 + format!( + "WITH d AS (DELETE FROM base_role_relation \ + WHERE f_object_type = 'user' AND f_object_id = $1::text) \ + INSERT INTO base_role_relation \ + (f_id, f_tenant_id, f_object_type, f_object_id, f_role_id, f_sort_code, f_delete_mark) \ + SELECT v.f_id, '0', 'user', $1::text, v.f_role_id, 0, 0 \ + FROM (VALUES {}) AS v(f_id, f_role_id)", + rows.join(", ") + ) + }; + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return Err(e); + } + Ok(()) +} + +/// 用户 Save 的响应体 = 落库后该用户行(**去掉 password**)+ `roleIds` + `roleNames`。 +async fn user_payload(state: &AppState, user_id: &str) -> Json { + let row = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, user_id).await { + Ok(v) => v, + Err(e) => return db_error(e, "读回用户"), + }; + let Some(mut obj) = row.and_then(|r| r.as_object().cloned()) else { + return fail(400, "用户不存在"); + }; + let role_map = match user_role_map(&state.db).await { + Ok(m) => m, + Err(e) => return db_error(e, "用户角色关系查询"), + }; + let (role_ids, role_names) = role_map.get(user_id).cloned().unwrap_or_default(); + obj.insert("roleIds".to_string(), json!(role_ids)); + obj.insert("roleNames".to_string(), json!(role_names)); + ok(Value::Object(obj)) +} + +// ---------------------------------------------------------------- Role + +/// `GET /api/ssw/sys/Role/List`(契约 §7.2)。 +pub async fn role_list(State(state): State, headers: HeaderMap) -> Json { + if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { + return resp; + } + let sql = format!( + "SELECT {ROLE_COLUMNS} FROM base_role WHERE f_delete_mark = 0 ORDER BY f_sort_code ASC" + ); + match state.db.query_json(&sql).await { + Ok(rows) => ok(Value::Array(rows)), + Err(e) => db_error(e, "角色列表查询"), + } +} + +/// `POST /api/ssw/sys/Role/Save`(契约 §7.2)。 +pub async fn role_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { + return resp; + } + let obj = match body_object(&body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); + if full_name.is_empty() { + return fail(400, "角色名称不能为空"); + } + let full_name = full_name.to_string(); + + let id = body_id(&obj); + + match id { + // ---- 新建 ---- + None => { + // 先查重 `f_en_code`(只比未软删的行)。 + let en_code = value_to_text(obj.get("enCode")); + if let Some(code) = &en_code { + let dup = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_role \ + WHERE f_en_code = $1::text AND f_delete_mark = 0 LIMIT 1", + &[code], + ) + .await + { + Ok(rows) => rows.first().is_some(), + Err(e) => return db_error(e, "角色查重"), + }; + if dup { + return fail(400, format!("角色编码已存在:{code}")); + } + } + let new_id = new_uuid(); + // `f_type` = `body.type ?? 'user'`。 + let role_type = match obj.get("type") { + Some(Value::Null) | None => "user".to_string(), + Some(v) => value_to_text(Some(v)).unwrap_or_else(|| "user".to_string()), + }; + let description = value_to_text(obj.get("description")); + let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); + let now = now_str(); + let values: Vec> = vec![ + Some(new_id.clone()), + Some("0".to_string()), + Some(full_name), + en_code, + Some(role_type), + description, + Some("1".to_string()), + Some(sort_code.to_string()), + Some("admin".to_string()), + Some(now), + Some("0".to_string()), + ]; + let sql = "INSERT INTO base_role \ + (f_id, f_tenant_id, f_full_name, f_en_code, f_type, f_description, \ + f_enabled_mark, f_sort_code, f_creator_user_id, f_creator_time, f_delete_mark) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ + $7::text::integer, $8::text::bigint, $9::text, $10::text::timestamp, \ + $11::text::integer)"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "新建角色"); + } + role_payload(&state, &new_id).await + } + // ---- 更新 ---- + Some(role_id) => { + // 🔴 按 `f_id` 查,**不带 `f_delete_mark` 过滤**。 + let existing = match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, &role_id).await { + Ok(v) => v, + Err(e) => return db_error(e, "角色查询"), + }; + let Some(existing) = existing else { + return fail(400, "角色不存在"); + }; + // ⚠️ 更新**不做** `f_en_code` 查重;**不碰** `f_sort_code` / `f_enabled_mark`。 + let mut fields: Vec = Vec::new(); + fields.push(Field { + column: "f_full_name", + cast: "", + value: Some(full_name), + }); + if obj.contains_key("enCode") { + fields.push(Field { + column: "f_en_code", + cast: "", + value: value_to_text(obj.get("enCode")), + }); + } + // `f_type` = `body.type ?? 原值`。 + fields.push(Field { + column: "f_type", + cast: "", + value: match obj.get("type") { + Some(Value::Null) | None => existing + .get("type") + .and_then(Value::as_str) + .map(str::to_string), + Some(v) => value_to_text(Some(v)), + }, + }); + if obj.contains_key("description") { + fields.push(Field { + column: "f_description", + cast: "", + value: value_to_text(obj.get("description")), + }); + } + let (sql, values) = match build_update("base_role", &role_id, &fields) { + Ok(v) => v, + Err(e) => return db_error(e, "构造角色更新语句"), + }; + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "更新角色"); + } + role_payload(&state, &role_id).await + } + } +} + +/// `DELETE /api/ssw/sys/Role/Delete?id=`(契约 §7.2)。 +pub async fn role_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { + return resp; + } + let id = query_param(&raw, "id"); + // 软删角色 + 软删该角色的授权 + 硬删该角色的关系 ⇒ **一条语句**(原子)。 + let sql = "WITH a AS (UPDATE base_role SET f_delete_mark = 1 WHERE f_id = $1::text), \ + b AS (UPDATE base_authorize SET f_delete_mark = 1 \ + WHERE f_object_type = 'role' AND f_object_id = $1::text), \ + c AS (DELETE FROM base_role_relation WHERE f_role_id = $1::text) \ + SELECT 1"; + if let Err(e) = state.db.exec_params(sql, &[&id]).await { + return db_error(e, "删除角色"); + } + ok(Value::Null) +} + +/// `GET /api/ssw/sys/Role/Modules?roleId=`(契约 §7.2)—— **仅登录**。 +pub async fn role_modules( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login(&state, &headers).await { + return resp; + } + let role_id = query_param(&raw, "roleId"); + match role_module_ids(&state.db, &role_id).await { + Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), + Err(e) => db_error(e, "角色菜单查询"), + } +} + +/// 角色的菜单 id 列表(契约 §7.2 / §7.5 —— 两处同一份语义)。 +async fn role_module_ids(db: &Db, role_id: &str) -> Result, pglite::Error> { + let rows = db + .query_json_params( + "SELECT f_item_id AS \"itemId\" FROM base_authorize \ + WHERE f_object_type = 'role' AND f_item_type = 'module' \ + AND f_object_id = $1::text AND f_delete_mark = 0", + &[&role_id], + ) + .await?; + Ok(rows + .iter() + .filter_map(|r| r.get("itemId").and_then(Value::as_str)) + .map(str::to_string) + .collect()) +} + +/// 角色 Save 的响应体 = 落库后该角色行。 +async fn role_payload(state: &AppState, role_id: &str) -> Json { + match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, role_id).await { + Ok(Some(row)) => ok(row), + Ok(None) => fail(400, "角色不存在"), + Err(e) => db_error(e, "读回角色"), + } +} + +// ---------------------------------------------------------------- Organize + +/// `GET /api/ssw/sys/Organize/List`(契约 §7.3)。 +pub async fn organize_list( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { + return resp; + } + let sql = format!( + "SELECT {ORGANIZE_COLUMNS} FROM base_organize WHERE f_delete_mark = 0 \ + ORDER BY f_sort_code ASC" + ); + match state.db.query_json(&sql).await { + Ok(rows) => ok(Value::Array(rows)), + Err(e) => db_error(e, "机构列表查询"), + } +} + +/// `POST /api/ssw/sys/Organize/Save`(契约 §7.3)。 +pub async fn organize_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { + return resp; + } + let obj = match body_object(&body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); + if full_name.is_empty() { + return fail(400, "机构名称不能为空"); + } + let full_name = full_name.to_string(); + + let id = body_id(&obj); + + match id { + // ---- 新建 ---- + None => { + let new_id = new_uuid(); + let parent_id = or_zero(obj.get("parentId")); + // `f_category` = `body.category ?? NULL`。 + let category = match obj.get("category") { + Some(Value::Null) | None => None, + Some(v) => value_to_text(Some(v)), + }; + let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); + let now = now_str(); + // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_organize` entity 没有该列)。 + let values: Vec> = vec![ + Some(new_id.clone()), + Some("0".to_string()), + Some(full_name), + Some(parent_id), + category, + Some(sort_code.to_string()), + Some("1".to_string()), + Some(now), + Some("0".to_string()), + ]; + let sql = "INSERT INTO base_organize \ + (f_id, f_tenant_id, f_full_name, f_parent_id, f_category, f_sort_code, \ + f_enabled_mark, f_creator_time, f_delete_mark) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::bigint, \ + $7::text::integer, $8::text::timestamp, $9::text::integer)"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "新建机构"); + } + organize_payload(&state, &new_id).await + } + // ---- 更新 ---- + Some(org_id) => { + let existing = + match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, &org_id).await { + Ok(v) => v, + Err(e) => return db_error(e, "机构查询"), + }; + let Some(existing) = existing else { + return fail(400, "机构不存在"); + }; + // ⚠️ 更新**不碰** `f_sort_code` / `f_enabled_mark`。 + let mut fields: Vec = Vec::new(); + fields.push(Field { + column: "f_full_name", + cast: "", + value: Some(full_name), + }); + fields.push(Field { + column: "f_parent_id", + cast: "", + value: Some(or_zero(obj.get("parentId"))), + }); + // `f_category` = `body.category ?? 原值`。 + fields.push(Field { + column: "f_category", + cast: "", + value: match obj.get("category") { + Some(Value::Null) | None => existing + .get("category") + .and_then(Value::as_str) + .map(str::to_string), + Some(v) => value_to_text(Some(v)), + }, + }); + let (sql, values) = match build_update("base_organize", &org_id, &fields) { + Ok(v) => v, + Err(e) => return db_error(e, "构造机构更新语句"), + }; + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "更新机构"); + } + organize_payload(&state, &org_id).await + } + } +} + +/// `DELETE /api/ssw/sys/Organize/Delete?id=`(契约 §7.3)。 +pub async fn organize_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { + return resp; + } + let id = query_param(&raw, "id"); + // 先查子机构:有 ⇒ 拒删。 + let children = match state + .db + .query_json_params( + "SELECT f_id AS \"id\" FROM base_organize \ + WHERE f_parent_id = $1::text AND f_delete_mark = 0 LIMIT 1", + &[&id], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "子机构查询"), + }; + if !children.is_empty() { + return fail(400, "该机构下还有子机构,先删除子机构"); + } + let sql = "UPDATE base_organize SET f_delete_mark = 1 WHERE f_id = $1::text"; + if let Err(e) = state.db.exec_params(sql, &[&id]).await { + return db_error(e, "删除机构"); + } + ok(Value::Null) +} + +/// 机构 Save 的响应体 = 落库后该机构行。 +async fn organize_payload(state: &AppState, org_id: &str) -> Json { + match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, org_id).await { + Ok(Some(row)) => ok(row), + Ok(None) => fail(400, "机构不存在"), + Err(e) => db_error(e, "读回机构"), + } +} + +// ---------------------------------------------------------------- Module + +/// `GET /api/ssw/sys/Module/List`(契约 §7.4)。 +pub async fn module_list( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { + return resp; + } + let sql = format!( + "SELECT {MODULE_COLUMNS} FROM base_module WHERE f_delete_mark = 0 \ + ORDER BY f_sort_code ASC" + ); + match state.db.query_json(&sql).await { + Ok(rows) => ok(Value::Array(rows)), + Err(e) => db_error(e, "菜单列表查询"), + } +} + +/// `POST /api/ssw/sys/Module/Save`(契约 §7.4)。 +pub async fn module_save( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { + return resp; + } + let obj = match body_object(&body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); + if full_name.is_empty() { + return fail(400, "菜单名称不能为空"); + } + let full_name = full_name.to_string(); + + let id = body_id(&obj); + + match id { + // ---- 新建 ---- + None => { + let new_id = new_uuid(); + let url_address = value_to_text(obj.get("urlAddress")); + let parent_id = or_zero(obj.get("parentId")); + // 🔴 `f_type` 是 **INTEGER**(1=目录 / 2=页面),缺省 **2**。 + let module_type = value_to_i64(obj.get("type")).unwrap_or(2); + // `f_category` 是 **VARCHAR 分类**,缺省 NULL。 + let category = match obj.get("category") { + Some(Value::Null) | None => None, + Some(v) => value_to_text(Some(v)), + }; + let icon = value_to_text(obj.get("icon")); + let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); + let now = now_str(); + // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_module` entity 没有该列)。 + let values: Vec> = vec![ + Some(new_id.clone()), + Some("0".to_string()), + Some(full_name), + url_address, + Some(parent_id), + Some(module_type.to_string()), + category, + icon, + Some(sort_code.to_string()), + Some("1".to_string()), + Some(now), + Some("0".to_string()), + ]; + let sql = "INSERT INTO base_module \ + (f_id, f_tenant_id, f_full_name, f_url_address, f_parent_id, f_type, \ + f_category, f_icon, f_sort_code, f_enabled_mark, f_creator_time, f_delete_mark) \ + VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ + $7::text, $8::text, $9::text::bigint, $10::text::integer, \ + $11::text::timestamp, $12::text::integer)"; + if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { + return db_error(e, "新建菜单"); + } + module_payload(&state, &new_id).await + } + // ---- 更新 ---- + Some(module_id) => { + let existing = + match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, &module_id).await { + Ok(v) => v, + Err(e) => return db_error(e, "菜单查询"), + }; + let Some(existing) = existing else { + return fail(400, "菜单不存在"); + }; + let mut fields: Vec = Vec::new(); + fields.push(Field { + column: "f_full_name", + cast: "", + value: Some(full_name), + }); + // 🔴 `f_url_address` **body 没这个键 ⇒ 不动原值** —— + // 它是权限守卫的比对键,被清成 NULL 会造成「静默越权」(裁决 S16)。 + if obj.contains_key("urlAddress") { + fields.push(Field { + column: "f_url_address", + cast: "", + value: value_to_text(obj.get("urlAddress")), + }); + } + fields.push(Field { + column: "f_parent_id", + cast: "", + value: Some(or_zero(obj.get("parentId"))), + }); + // `f_type` = `body.type ?? 原值`。 + let orig_type = existing.get("type").and_then(Value::as_i64); + let new_type = match obj.get("type") { + Some(Value::Null) | None => orig_type, + Some(v) => value_to_i64(Some(v)).or(orig_type), + }; + fields.push(Field { + column: "f_type", + cast: "::integer", + value: new_type.map(|v| v.to_string()), + }); + // `f_category` = `body.category ?? 原值`。 + fields.push(Field { + column: "f_category", + cast: "", + value: match obj.get("category") { + Some(Value::Null) | None => existing + .get("category") + .and_then(Value::as_str) + .map(str::to_string), + Some(v) => value_to_text(Some(v)), + }, + }); + // `f_icon`:**body 没这个键 ⇒ 不动原值**。 + if obj.contains_key("icon") { + fields.push(Field { + column: "f_icon", + cast: "", + value: value_to_text(obj.get("icon")), + }); + } + // `f_sort_code` = `body.sortCode ?? 0`(⚠️ 缺省 ⇒ **0**,不是原值)。 + fields.push(Field { + column: "f_sort_code", + cast: "::bigint", + value: Some(value_to_i64(obj.get("sortCode")).unwrap_or(0).to_string()), + }); + let (sql, values) = match build_update("base_module", &module_id, &fields) { + Ok(v) => v, + Err(e) => return db_error(e, "构造菜单更新语句"), + }; + if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { + return db_error(e, "更新菜单"); + } + module_payload(&state, &module_id).await + } + } +} + +/// `DELETE /api/ssw/sys/Module/Delete?id=`(契约 §7.4)。 +pub async fn module_delete( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { + return resp; + } + let id = query_param(&raw, "id"); + // 软删菜单 + 软删该菜单的授权 ⇒ **一条语句**(原子)。 + let sql = "WITH a AS (UPDATE base_module SET f_delete_mark = 1 WHERE f_id = $1::text), \ + b AS (UPDATE base_authorize SET f_delete_mark = 1 \ + WHERE f_item_type = 'module' AND f_item_id = $1::text) \ + SELECT 1"; + if let Err(e) = state.db.exec_params(sql, &[&id]).await { + return db_error(e, "删除菜单"); + } + ok(Value::Null) +} + +/// 菜单 Save 的响应体 = 落库后该菜单行。 +async fn module_payload(state: &AppState, module_id: &str) -> Json { + match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, module_id).await { + Ok(Some(row)) => ok(row), + Ok(None) => fail(400, "菜单不存在"), + Err(e) => db_error(e, "读回菜单"), + } +} + +// ---------------------------------------------------------------- 授权 + +/// `PUT /api/permission/Authority/Data/{objectId}`(契约 §7.5)—— **仅登录**。 +/// +/// 🔴 **body 里的 `objectType` 被完全忽略**(react 只读 `body.module`) +/// ⇒ 落库一律 `f_object_type='role'`、`f_item_type='module'`、`f_object_id=`。 +/// **不要**因为 body 传了 `'Role'` 就拒绝(裁决:react 不校验,本仓也不校验)。 +/// +/// 🔴 **面 B 分流**:未登录时面 A 返 `600`、面 B 返 `602` +/// (官方前端只对 `601`/`602` 清 token ⇒ 返 `600` 会卡住不跳登录)。 +pub async fn authority_data( + State(state): State, + headers: HeaderMap, + Path(object_id): Path, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_any(&state, &headers).await { + return resp; + } + let obj = match body_object(&body) { + Ok(o) => o, + Err(resp) => return resp, + }; + let module_ids = normalize_module(obj.get("module")); + if let Err(e) = write_role_modules(&state.db, &object_id, &module_ids).await { + return db_error(e, "写授权"); + } + ok(Value::Null) +} + +/// `GET /api/permission/Authority/RoleModules?roleId=`(契约 §7.5)—— **仅登录**。 +pub async fn authority_role_modules( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login(&state, &headers).await { + return resp; + } + let role_id = query_param(&raw, "roleId"); + match role_module_ids(&state.db, &role_id).await { + Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), + Err(e) => db_error(e, "角色菜单查询"), + } +} + +/// 归一化 `module`(react 的 `normalizeModule`)。 +/// +/// - **不是数组**(缺省 / 类型不对)⇒ `[]`; +/// - `module[0]` 是数组 ⇒ **展平一层**(兼容官方前端的 `[checked, halfChecked]` 二维形态); +/// - 只保留**非空字符串**。 +fn normalize_module(raw: Option<&Value>) -> Vec { + let Some(Value::Array(items)) = raw else { + return Vec::new(); + }; + let flatten = matches!(items.first(), Some(Value::Array(_))); + let mut out: Vec = Vec::new(); + for item in items { + if flatten { + match item { + Value::Array(inner) => { + for x in inner { + if let Some(s) = x.as_str() { + if !s.is_empty() { + out.push(s.to_string()); + } + } + } + } + other => { + if let Some(s) = other.as_str() { + if !s.is_empty() { + out.push(s.to_string()); + } + } + } + } + } else if let Some(s) = item.as_str() { + if !s.is_empty() { + out.push(s.to_string()); + } + } + } + out +} + +/// 写「角色 → 菜单」授权:先软删旧行,再插新行。 +/// +/// 🔴 **一条语句**(data-modifying CTE)⇒ 软删 + 插入原子(裁决 P59)。 +/// ⚠️ 空数组 ⇒ **只软删不插**。 +async fn write_role_modules( + db: &Db, + object_id: &str, + module_ids: &[String], +) -> Result<(), pglite::Error> { + if module_ids.is_empty() { + let sql = "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ + WHERE f_object_type = 'role' AND f_item_type = 'module' \ + AND f_object_id = $1::text) \ + SELECT 1"; + db.exec_params(sql, &[&object_id]).await?; + return Ok(()); + } + let mut values: Vec> = vec![Some(object_id.to_string())]; + let mut rows: Vec = Vec::new(); + for module_id in module_ids { + values.push(Some(new_uuid())); + values.push(Some(module_id.clone())); + rows.push(format!( + "(${}::text, ${}::text)", + values.len() - 1, + values.len() + )); + } + let sql = format!( + "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ + WHERE f_object_type = 'role' AND f_item_type = 'module' \ + AND f_object_id = $1::text) \ + INSERT INTO base_authorize \ + (f_id, f_tenant_id, f_object_type, f_object_id, f_item_id, f_item_type, \ + f_sort_code, f_delete_mark) \ + SELECT v.f_id, '0', 'role', $1::text, v.f_item_id, 'module', 0, 0 \ + FROM (VALUES {}) AS v(f_id, f_item_id)", + rows.join(", ") + ); + db.exec_params(&sql, ¶ms_of(&values)).await?; + Ok(()) +} diff --git a/crates/sspf-core/src/variate_catalog.rs b/crates/sspf-core/src/variate_catalog.rs new file mode 100644 index 0000000..bf7a3f8 --- /dev/null +++ b/crates/sspf-core/src/variate_catalog.rs @@ -0,0 +1,476 @@ +//! 公式编辑器的**函数目录**与**系统变量目录**。 +//! +//! 🔴 **本文件是生成物,不许手改** —— 由 `scripts/gen-function-catalog.py` +//! 从官方 Java 枚举逐条转出: +//! `jnpf-system-entity/.../model/variate/{FunctionTypeEnum,SystemVariateEnum}.java` +//! 改了官方枚举就重跑脚本;`gen-function-catalog.py --check` 是闸门。 +//! +//! 为什么值得生成:这 100+ 条是**前端公式编辑器的下拉与帮助文本**(含 HTML), +//! 手抄漏一条不会有任何编译/测试报错,只会让某个函数在帮助里点不开。 + +/// 一条公式函数。 +pub struct FuncEntry { + /// 函数名(`SUM` / `ROUND` …),也是表达式里的写法。 + pub name: &'static str, + /// 帮助文本(**HTML 片段**,前端直接 v-html 渲染)。 + pub description: &'static str, + /// 分类枚举名(`MATH` / `TIME` …)。 + pub category: &'static str, + /// 分类中文名(`数学函数` …)—— 与 `category` 一一对应,冗余存一份。 + pub sub_category: &'static str, +} + +/// 一条系统变量(`@userId` 之类,公式里可直接引用)。 +pub struct VariateEntry { + /// 变量名(含 `@` 前缀)。 + pub field: &'static str, + /// 中文说明。 + pub description: &'static str, +} + +/// 函数分类(官方 `FunctionCategory` 全量,**含** `ALL`)。 +pub const FUNCTION_CATEGORIES: &[(&str, &str)] = &[ + (r#"ALL"#, r#"全部函数"#), + (r#"ENCRYPTION"#, r#"加解密函数"#), + (r#"MASKING"#, r#"脱敏函数"#), + (r#"OBJECT"#, r#"对象函数"#), + (r#"MATH"#, r#"数学函数"#), + (r#"COMMON"#, r#"常用函数"#), + (r#"TIME"#, r#"时间函数"#), + (r#"CONVERSION"#, r#"转换函数"#), + (r#"COLLECTION"#, r#"集合函数"#), + (r#"TEXT"#, r#"文本函数"#), + (r#"LOGIC"#, r#"逻辑函数"#), +]; + +/// 公式函数目录(35 条,官方 `FunctionTypeEnum` 逐条)。 +pub const FUNCTIONS: &[FuncEntry] = &[ + FuncEntry { + name: r#"SUM"#, + description: r#"
    +
  • SUM函数可以获取一组数值的总和
  • +
  • 用法:SUM(数值1,数值2,...)
  • +
  • 示例:SUM(语文成绩,数学成绩)返回两门课程总分
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"MAX"#, + description: r#"
    +
  • MAX函数可以获取一组数值的最大值
  • +
  • 用法:MAX(数字1,数字2,...)
  • +
  • 示例:MAX(语文成绩,数学成绩,英语成绩)返回三门课程中的最高分
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"MIN"#, + description: r#"
    +
  • MIN函数可以获取一组数值的最小值
  • +
  • 用法:MIN(数字1,数字2,...)
  • +
  • 示例:MIN(语文成绩,数学成绩,英语成绩)返回三门课程中的最低分
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"PRODUCT"#, + description: r#"
    +
  • PRODUCT函数可以获取一组数值的乘积
  • +
  • 用法:PRODUCT(数值1,数值2,...)
  • +
  • 示例:PRODUCT(单价,数量)获取总价,即单价和数量的乘积
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"ROUND"#, + description: r#"
    +
  • ROUND函数可以将数字四舍五入到指定的位数
  • +
  • 用法:ROUNDROUND(数字,数字位数)
  • +
  • 示例:ROUNDROUND(3.1485,2)返回3.15
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"COUNT"#, + description: r#"
    +
  • COUNT函数可以获取参数的数量
  • +
  • 用法:COUNT(值,值,...)
  • +
  • 示例:COUNT(小王,小李)返回2,即人员数量
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"DIVIDE"#, + description: r#"
    +
  • DIVIDE函数可以返回数值相除
  • +
  • 用法:DIVIDE(被除数,除数)
  • +
  • 示例:DIVIDE(总价,单价)获取数量,即总价除单价
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"SUBTRACT"#, + description: r#"
    +
  • SUBTRACT函数可以返回数值相减
  • +
  • 用法:SUBTRACT(被减数,减数)
  • +
  • 示例:SUBTRACT(总收入,总支出)返回收支总利润
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"MOD"#, + description: r#"
    +
  • MOD函数可以获取两数相除的余数
  • +
  • 用法:MOD(被除数,除数)
  • +
  • 示例:MOD(4,3)返回1,也就是4/3的余数
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"ABS"#, + description: r#"
    +
  • ABS函数可以获取一个数的绝对值
  • +
  • 用法:ABS(数字)
  • +
  • 示例:ABS(-8)可以返回8,也就是-8的绝对值
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"INT"#, + description: r#"
    +
  • INT函数可以获取一个数的整数部分
  • +
  • 用法:INT(数字)
  • +
  • 示例:INT(3.1415)返回3,也就是3.1415的整数部分
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"POWER"#, + description: r#"
    +
  • POWER函数可以获取数字乘幂的结果
  • +
  • 用法:POWER(数字,指数)
  • +
  • 示例:POWER(3,2)返回9,也就是3的2次方
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"FIXED"#, + description: r#"
    +
  • FIXED函数可将数字舍入到指定的小数位数并输出为文本
  • +
  • 用法:FIXED(数字,小数位数)
  • +
  • 示例:FIXED(3.1415,2)返回"3.14"
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"SQRT"#, + description: r#"
    +
  • SQRT函数可以获取一个数字的正平方根
  • +
  • 用法:SQRT(数字)
  • +
  • 示例:SQRT(9)返回3,也就是9的正平方根
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"LARGE"#, + description: r#"
    +
  • LARGE函数可以获取数据集中第k个最大值
  • +
  • 用法:LARGE(数组,k)
  • +
  • 示例:LARGE(学生成绩.数学成绩,1)返回子表单"学生成绩"中排名第1的"数学成绩"
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"SMALL"#, + description: r#"
    +
  • SMALL函数可以返回数据集中第k个最小值
  • +
  • 用法:SMALL(数组,k)
  • +
  • 示例:SMALL(学生成绩.数学成绩, 1)返回子表单"学生成绩"中排名倒数第一的"数学成绩"
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"AVERAGE"#, + description: r#"
    +
  • AVERAGE函数可以获取一组数值的算术平均值
  • +
  • 用法:AVERAGE(数字1,数字2,...)
  • +
  • 示例:AVERAGE(语文成绩,数学成绩, 英语成绩)返回三门课程的平均分
  • +
"#, + category: r#"MATH"#, + sub_category: r#"数学函数"#, + }, + FuncEntry { + name: r#"SPLIT"#, + description: r#"
    +
  • SPLIT函数可以将文本按指定分割符分割成数组,需配合ARRAYGET来获取指定位置字 +符,ARRAYGET(SPLIT(text,text separator),1)
  • +
  • 用法:SPLIT(文本,分隔符_文本)
  • +
  • 示例:SPLIT("JNPF-快速开发平台","-")返回"JNPF,快速开发平台"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"TEXT"#, + description: r#"
    +
  • TEXT函数可以将数字转化成文本
  • +
  • 用法:TEXT(数字)
  • +
  • 示例:TEXT(3.1415)返回"3.1415"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"TRIM"#, + description: r#"
    +
  • TRIM函数可以删除文本首尾的空格
  • +
  • 用法:TRIM(文本)
  • +
  • 示例:TRIM(" JNPF ")返回"JNPF"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"UUID"#, + description: r#"
    +
  • UUID函数用于随机码生成
  • +
  • 用法:UUID()
  • +
  • 示例:CONCATENATE("JNPF-",UUID())生成JNPF-开头的流水号,比如JNPF-FYJQ03VCOA03KCE20YW45E7OIMC390UJU2MK0
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"VALUE"#, + description: r#"
    +
  • VALUE函数可以将文本转化为数字
  • +
  • 用法:VALUE(文本)
  • +
  • 示例:VALUE("3.1415")返回3.1415
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"SEARCH"#, + description: r#"
    +
  • SEARCH函数可以获取文本1在文本2中的开始位置
  • +
  • 用法:SEARCH(文本1,文本2)
  • +
  • 示例:SEARCH("2026","JNPF2026")返回5
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"RMBFORMAT"#, + description: r#"
    +
  • RMBFORMAT函数可以将数字格式化为人民币格式
  • +
  • 用法:RMBFORMAT(mumher,[type])
  • +
  • 示例:RMBFORMAT(数字输入框)输入123,返回壹佰贰拾参元整
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"REPT"#, + description: r#"
    +
  • REPT函数可以将文本重复一定次数
  • +
  • 用法:REPT(文本,重复次数)
  • +
  • 示例:REPT("JNPF", 3)返回"JNPFJNPFJNPF"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"REPLACE"#, + description: r#"
    +
  • REPLACE函数可以根据指定的字符数,将部分文本替换为不同的文本
  • +
  • 用法:REPLACE(文本,开始位置,替换长度,新文本)
  • +
  • 示例:REPLACE("JNPF快速开发平台",5,10,"数字化平台")返回"JNPF数字化平台
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"PINYINHEADCHAR"#, + description: r#"
    +
  • PINYINHEADCHAR函数可以将字符串中的每个字的首字母以大写形式拼接返回
  • +
  • 用法:PINYINHEADCHAR(文本)
  • +
  • 示例:PINYINHEADCHAR("JNPF快速开发平台") + // 返回"JNPFKSKFPT"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"MID"#, + description: r#"
    +
  • MID函数返回文本中从指定位置开始的指定数目的字符
  • +
  • 用法:MID(文本,开始位置_数字,指定数目)
  • +
  • 示例:MID("JNPF快速开发平台",5,6)返回"快速开发平台"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"UPPER"#, + description: r#"
    +
  • UPPER函数可以将一个文本中的所有小写字母转换为大写字母
  • +
  • 用法:UPPER(文本)
  • +
  • 示例:UPPER("jnpf")返回"JNPF"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"LOWER"#, + description: r#"
    +
  • LOWER函数可以将一个文本中的所有大写字母转换为小写字母
  • +
  • 用法:LOWER(文本)
  • +
  • 示例:LOWER("JNPF")返回"jnpf"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"LEN"#, + description: r#"
    +
  • LEN函数可以获取文本中的字符个数
  • +
  • 用法:LEN(文本)
  • +
  • 示例:LEN("JNPF快速开发平台")返回10,因为这句诗中有10个字符
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"RIGHT"#, + description: r#"
    +
  • RIGHT函数可以获取由给定文本右端指定数量的字符构成的文本值
  • +
  • 用法:RIGHT(文本,文本长度)
  • +
  • 示例:RIGHT("JNPF快速开发平台",4)返回"开发平台",也就是"JNPF快速开发平台"从右往左的前4个字符
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"LEFT"#, + description: r#"
    +
  • LEFT函数可以从一个文本的第一个字符开始返回指定个数的字符
  • +
  • 用法:LEFT(文本,文本长度)
  • +
  • 示例:LEFT("JNPF快速开发平台",4)返回"JNPF",也就是"JNPF快速开发平台"的从左往右的前4个字符
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"CONCATENATE"#, + description: r#"
    +
  • CONCATENATE函数可以将多个文本合并成一个文本
  • +
  • 用法:CONCATENATE(文本1,文本2,...)
  • +
  • 示例:CONCATENATE("JNPF","快速开发平台")会返回"JNPF快速开发平台"
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, + FuncEntry { + name: r#"ARRAYGET"#, + description: r#"
    +
  • ARRAYGET函数用于返回数据集中第k个值
  • +
  • 用法:ARRAYGET(array, k)
  • +
  • 示例:ARRAYGET(SPLIT("JNPF-应用定制工具","-"),1)返回JNPF
  • +
"#, + category: r#"TEXT"#, + sub_category: r#"文本函数"#, + }, +]; + +/// 系统变量目录(18 条,官方 `SystemVariateEnum` 逐条)。 +pub const SYSTEM_VARIATES: &[VariateEntry] = &[ + VariateEntry { + field: r#"@userId"#, + description: r#"当前用户"#, + }, + VariateEntry { + field: r#"@userAndSub"#, + description: r#"当前用户及下属"#, + }, + VariateEntry { + field: r#"@userAndProgeny"#, + description: r#"当前用户及子孙下属"#, + }, + VariateEntry { + field: r#"@organizeId"#, + description: r#"当前用户所属组织"#, + }, + VariateEntry { + field: r#"@organizeAndSub"#, + description: r#"当前用户所属组织及子组织"#, + }, + VariateEntry { + field: r#"@organizeAndProgeny"#, + description: r#"当前用户所属组织及子孙组织"#, + }, + VariateEntry { + field: r#"@positionId"#, + description: r#"当前用户所属岗位"#, + }, + VariateEntry { + field: r#"@positionAndSub"#, + description: r#"当前用户所属岗位及子岗位"#, + }, + VariateEntry { + field: r#"@positionAndProgeny"#, + description: r#"当前用户所属岗位及子孙岗位"#, + }, + VariateEntry { + field: r#"@formId"#, + description: r#"表单ID"#, + }, + VariateEntry { + field: r#"@flowId"#, + description: r#"流程ID"#, + }, + VariateEntry { + field: r#"@taskId"#, + description: r#"任务ID"#, + }, + VariateEntry { + field: r#"@taskNodeId"#, + description: r#"任务节点ID"#, + }, + VariateEntry { + field: r#"@flowFullName"#, + description: r#"流程名称"#, + }, + VariateEntry { + field: r#"@taskFullName"#, + description: r#"任务标题"#, + }, + VariateEntry { + field: r#"@launchUserId"#, + description: r#"发起用户ID"#, + }, + VariateEntry { + field: r#"@launchUserName"#, + description: r#"发起用户名称"#, + }, + VariateEntry { + field: r#"@flowOperatorUserId"#, + description: r#"当前操作用户ID"#, + }, +]; diff --git a/docs/CRATES-MIGRATION.md b/docs/CRATES-MIGRATION.md index 850c8e9..8a5f68a 100644 --- a/docs/CRATES-MIGRATION.md +++ b/docs/CRATES-MIGRATION.md @@ -2,8 +2,9 @@ > **基线锚点**:`v0.1.0`(commit `b957a11`,已推送到 `origin`) > **制定时间**:2026-11-03 -> **状态**:**M1 已完成**(tag `v0.1.1-m1`)—— 三处循环依赖全部解开; -> 下一步 = M2(`sspf-core` 平台核心下沉) +> **状态**:**M2 已完成**(tag `v0.1.2-m2`)—— 平台核心 19 个模块下沉到 `crates/sspf-core/`, +> `platform/*.rs` 只剩转发壳;闸门同步改造(扫真源而非空壳)。 +> 下一步 = M3(`sspf-compat-core` 契约面公共底座) --- @@ -309,28 +310,46 @@ ssw-platform/ > 把那行加回去**照样编译通过、测试照样全绿**,只有到 M2 那天才炸 ⇒ 那时已改了一堆东西。 > ⇒ 现在就拦住。 -### 批次 M2 —— 平台核心下沉:`sspf-core` +### 批次 M2 —— 平台核心下沉:`sspf-core` ✅ 已完成(tag `v0.1.2-m2`) -**迁入**:`platform/{auth,session,authorization,crud,sys,menu,guard,monitor,registry,state,seed,variate_catalog}.rs` + `platform/{cipher,envelope,ids,config,db}.rs`(后四个转 `pub use sspf_store` / `sspf_contract` 转发) +**迁入**:`platform/{auth,authorization,cipher,config,crud,db,entity,envelope,guard,ids,menu,monitor,registry,route,seed,session,state,sys,variate_catalog}.rs`(**19 个模块**,全部 `git mv` 保留历史) -**新 crate**:`crates/sspf-core` -```toml -[dependencies] -sspf-contract = { path = "../sspf-contract" } -sspf-store = { path = "../sspf-store" } -axum = { workspace = true } -tokio = { workspace = true } -serde = { workspace = true } -serde_json = { workspace = true } -``` +**新 crate**:`crates/sspf-core`(依赖 sspf-contract / sspf-store / axum / tokio / serde / serde_json / chrono / rand / libc) -**保留转发壳**:`src/backend/src/platform/*.rs` 全部改成 `pub use sspf_core::*;` +**保留转发壳**:`src/backend/src/platform/*.rs` 全部改成 `pub use sspf_core::::*;` ⇒ **上层零感知**(测试、routes、modules 全部不用改 import)。 > 🔴 **`state.rs`(AppState)是关键**:`config`/`db`/`sessions`/`tickets` 四个 `Arc`。 > 它必须跟着 core 走(compat 包也要用 AppState)⇒ 放在 `sspf-core` 最底部。 -**出口判据**:`src/backend/src/platform/` 每个文件 ≤ 10 行(纯 re-export);695 测试仍全绿。 +**实际做法(与原计划的差异)**: +1. **`pub(crate)` → `pub`**:跨 crate 后 `pub(crate)` 失效 —— `crud::{handle_list,handle_save,handle_delete,handle_*_face_b,value_to_text}`、`auth::{client_ip,parse_user_agent}`、`sys::query_param` 共 10 处提为 `pub`。 +2. **测试归属跟着依赖走**:`crud.rs` 的 3 个测试原依赖 `crate::modules::all_specs()`(业务层)⇒ core 不能反向依赖业务层。**解法**:改用**契约层合成 spec**(同表结构、无业务知识)做参数化测试,断言强度不降;顺带发现 `write_cast` 的 numeric 映射是**列名枚举**(`f_price`/`f_stock`)而非 spec 声明 ⇒ 记为技术债(现有列名恰好都叫 `f_price` 未暴雷,新表带 `f_amount` 会静默出错)。 +3. **`registry.rs` 测试自建库**:不再经 `bootstrap::ensure_base`(那是装配根、认识业务层),改 `seed::ensure_base(db, &[])`(无业务菜单)⇒ 断言仍是主系统 5 条内置菜单(`m_sys`/`m_user`/`m_role`/`m_org`/`m_menu`)。 +4. **`test_support.rs` 留壳层**:它依赖 `bootstrap::ensure_schema_all`(认识业务 DDL)⇒ 不进 core。 +5. **路径改写**:crate 内 `crate::platform::X` → `crate::X`(`compat` 除外,那是 M3/M4 的)。 + +**闸门改造(🔴 本批次最大风险,不是代码是闸门)**: +搬迁后 `platform/` 只剩转发壳(`pub use`,无函数体)⇒ **闸门扫空壳 = 虚假安全感**。同步改造 5 处: +| 闸门 | 原路径(写死) | 改造后 | +|---|---|---| +| `check-arch.sh` AR9/AR10 | `$KERNEL/src/platform` | **两处都扫**:`crates/sspf-core/src`(真源)+ `platform/`(壳) | +| `check-arch.sh` 反自证 2/6、5/6 | 只注入壳目录 | **两处都注入**,且**按路径分别验**(单点注入会漏判) | +| `check-boundary.sh` CP1/CP2/CP6 | `$SRC/platform` | 新增 `PLATFORM_CORE`;CP6 的 `seed.rs` 改读真源 | +| `check-contract-scan.py` `plat_files` | 只收 `platform/*.rs` | **两处都收**,重名键**拼接**(否则守卫推不出 ⇒ CC6 退化成 WARN) | +| `check-module.sh` `CRUD` | `$BACKEND/src/platform/crud.rs` | 改读 `crates/sspf-core/src/crud.rs`(软删契约要看 SQL) | +| `gen-function-catalog.py` `OUT` | `platform/variate_catalog.rs` | 改写 `crates/sspf-core/src/variate_catalog.rs`(否则**覆盖转发壳**) | + +**反向验证**(证明闸门真在扫真源,不是碰巧通过):只往 `crates/sspf-core/src/` 塞 `use sspf_pack_asset::…` / `use crate::platform::compat::…` ⇒ AR9/AR10 **都报红**;探针已清干净。 + +**出口判据(全部达成)**: +- [x] `src/backend/src/platform/*.rs` 每个文件 ≤ 10 行(纯 re-export) +- [x] `cargo build --workspace` 零警告 +- [x] `cargo test --workspace` **695 passed / 0 failed**(与基线一致) +- [x] `check-arch.sh` 14/14;`--self-test` 6/6 +- [x] `check-boundary.sh` 11/11;`check-contract.sh` 10/10(反自证 12 例全过) +- [x] `check-module.sh` 123/123;`check-citations.sh` 4/4 +- [x] `verify.sh --smoke` 14 步全绿(512.3s) ### 批次 M3 —— 契约面公共底座:`sspf-compat-core` @@ -402,14 +421,14 @@ serde_json = { workspace = true } | 🆕 AR12 | — | `crates/sspf-compat-*` 之间**不许**互相依赖(防环回流) | | 🆕 AR13 | — | `crates/sspf-lowcode-exec` 依赖 ⊆ {lowcode, core, store, mcp} | -### 5.2 `scripts/check-contract-scan.py` +### 5.2 `scripts/check-contract-scan.py` ✅ M2 已做(部分) -**问题**:第 827 行 `plat_dir = os.path.join(src_dir, "platform")`、第 839 行 `compat_dir = ...` —— -代码搬走后这两个目录**不存在** ⇒ `plat_files` 为空 ⇒ **守卫推导全部推不出** ⇒ CC6 静默退化成「全是 WARN」。 +**问题**:`plat_dir = os.path.join(src_dir, "platform")` —— 代码搬走后只剩转发壳(无函数体)⇒ `plat_files` 推不出守卫 ⇒ CC6 静默退化成「全是 WARN」。**M2 实测**:反自证「守卫写错没被 CC6 抓到」当场报警 ⇒ 尺子**没**静默失效(自证起作用了)。 -**改造**: +**M2 改造(已做)**:`plat_files` **两处都收** —— `crates/sspf-core/src/*.rs`(真源)+ `src/backend/src/platform/*.rs`(壳),重名键**拼接**而非覆盖(否则一边的函数推不出守卫)。 + +**M4 后续(待做)**:`compat/` 搬走后要收 `sspf-compat-*` 各包: ```python -# 改成扫描所有 crates 平台包 PLAT_CRATES = ["sspf-core", "sspf-compat-core", "sspf-compat-system", ...] for c in PLAT_CRATES: d = os.path.join(ROOT, "crates", c, "src") @@ -417,16 +436,15 @@ for c in PLAT_CRATES: ``` **必须**在 M4 之后立刻做,并**重跑 `check-contract.sh --self-test`** 确认没退化。 -### 5.3 `scripts/check-boundary-scan.py` / `check-boundary.sh` +### 5.3 `scripts/check-boundary-scan.py` / `check-boundary.sh` ✅ M2 已做 **问题**:扫 `src/backend/src/platform/` 找业务标识符。代码搬走后**扫不到** ⇒ 平台层混入业务知识**不再被发现**。 -**改造**:扫目录改成「所有 crates 平台包」+ `src/backend/src`(薄壳也要扫)。 +**M2 改造(已做)**:新增 `PLATFORM_CORE="$ROOT/crates/sspf-core/src"`,CP1(业务标识符)/ CP2(`use crate::modules`)**两处都扫**;CP6 的 `seed.rs` 改读真源(`BUILTIN_MENUS` 在 core 里)。**实测**:改前 CP6 报「BUILTIN_MENUS 有 0 条」(读空壳)⇒ 改后 11/11 全绿。 -### 5.4 `scripts/check-module.sh` +### 5.4 `scripts/check-module.sh` ✅ M2 已做(CRUD 路径) -`BACKEND="$ROOT/src/backend"` + `src/backend/src/modules/.rs` —— -业务层**留在壳里** ⇒ **不用改** ✅(除非 M7 决定把业务层也搬走,**不建议**)。 +业务层(`modules/.rs`)**留在壳里** ⇒ 主体不用改;但**软删契约**(`WHERE f_delete_mark = 0` / `SET f_delete_mark = 1`)读 `crud.rs` ⇒ `CRUD` 变量改读 `crates/sspf-core/src/crud.rs`(转发壳里没有 SQL)。**实测**:改前 8 项软删检查全 ❌(读不到 SQL)⇒ 改后 123/123 全绿。 ### 5.5 `scripts/check-naming.sh` @@ -561,9 +579,10 @@ bash scripts/verify.sh --smoke # 14 步全绿 ## 12. 立即可做的下一步 -**执行 M1(解开三个循环)**。理由: -1. 不改目录结构 ⇒ 风险最低 -2. 是所有后续批次的**前置**(不解开,后面全部编译不过) -3. 单独可验证(编译过 + 695 测试仍全绿) +**执行 M3(契约面公共底座 `sspf-compat-core`)**。理由: +1. M1(解环)/ M2(平台核心下沉)已完成并打 tag —— 地基已稳 +2. `compat/helper.rs`(902 行)+ `res.rs`(460 行)是 **14 个契约面模块**的公共底座 ⇒ 先下沉它,M4 的 6 个包才都能依赖它 +3. 有现成套路可复用:M2 的「转发壳 + 闸门扫真源 + 反自证两处注入」直接套用 -M1 完成后打 tag `v0.1.1-m1`,再进 M2。 +M3 完成后打 tag `v0.1.3-m3`,再进 M4(6 个契约面包并行)。 +⚠️ M4 之后**必须**做 §5.2 的 `check-contract-scan.py` 兼容包收编 + 重跑 `--self-test`。 diff --git a/scripts/check-arch.sh b/scripts/check-arch.sh index d775f98..3a829e7 100755 --- a/scripts/check-arch.sh +++ b/scripts/check-arch.sh @@ -28,9 +28,10 @@ # —— 适配器只认工具契约层;依赖内核 store 就等于把第二种后端钉死在本进程旁 # AR7 `crates/sspf-lowcode` 依赖 ⊆ {sspf-contract, serde, serde_json} # —— 低代码引擎是纯计算;依赖 DB/HTTP 会让它只能在内核里跑,且测试必须起库 -# AR9 `src/backend/src/platform/**` 里不许出现 `use sspf_pack_*` +# AR9 平台层(真源 `crates/sspf-core/src/**` + 转发壳 `src/backend/src/platform/**`) +# 里不许出现 `use sspf_pack_*` # —— 平台层不许认识任何业务包(业务知识隔离) -# AR10 `src/backend/src/platform/**`(不含 compat/)里不许出现 +# AR10 平台层(同上两处,不含 compat/)里不许出现 # `crate::platform::compat` —— 平台层不许**反向依赖**契约面 # —— M1 解开的环 A;拆 crate 时它就是循环依赖(编译器当天才报错 ⇒ 必须提前钉住) # AR11 `src/backend/src/platform/compat/helper.rs` 里不许 `use super::<别的模块>` @@ -38,7 +39,7 @@ # —— M1 解开的环 B/C # MEM1 非注释代码里不许出现 `SELECT *` # —— 终端产品内存预算 ≤ 120MB(PLAN.md 判断 ⑥)⇒ 全表读进 Vec 直接爆 -# MEM2 `crates/**` 与 `src/backend/src/platform/**` 里不许出现无界 `HashMap` 缓存 +# MEM2 `crates/**` 与 `src/backend/src/**` 里不许出现无界 `HashMap` 缓存 # (近似检查:`static` + `Mutex` 是**允许**的(装配根要装载它们); -# 但 `src/backend/src/platform/**` 里出现 `use sspf_pack_*` ⇒ 平台层知道了 +# 但**平台层**里出现 `use sspf_pack_*` ⇒ 平台层知道了 # 具体业务 ⇒ 加/删业务包就要改平台层 ⇒ 「链接就好」这个承诺是假的。 +# 🔴 **M2 起平台层的真源在 `crates/sspf-core/src/`**,`src/backend/src/platform/` +# 只剩转发壳(`pub use sspf_core::*`)+ 尚未搬走的 `compat/`(M3/M4)。 +# ⇒ 闸门必须**两处都扫**:扫真源(管实现)+ 扫转发壳(防有人往壳里塞实现)。 +# 只扫壳 = 尺子量空壳 = 虚假安全感。 check_ar9() { - local dir="$KERNEL/src/platform" - [ -d "$dir" ] || { skip "AR9 平台层目录不存在"; return; } + local dirs=() + [ -d "$CRATES/sspf-core/src" ] && dirs+=("$CRATES/sspf-core/src") + [ -d "$KERNEL/src/platform" ] && dirs+=("$KERNEL/src/platform") + [ "${#dirs[@]}" -gt 0 ] || { skip "AR9 平台层目录不存在"; return; } local hits - hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "$dir" 2>/dev/null || true)" + hits="$(grep -rnE '^[[:space:]]*(pub )?use[[:space:]]+sspf_pack_' "${dirs[@]}" 2>/dev/null || true)" if [ -z "$hits" ]; then - ok "AR9 平台层没有 use sspf_pack_*(业务知识没漏进 platform/)" + ok "AR9 平台层没有 use sspf_pack_*(业务知识没漏进 sspf-core/ 或 platform/)" else - bad "AR9 平台层出现了业务包引用(业务知识漏进 platform/ ⇒ 加包要改平台层):" + bad "AR9 平台层出现了业务包引用(业务知识漏进平台层 ⇒ 加包要改平台层):" printf '%s\n' "$hits" | sed 's/^/ /' fi } @@ -234,41 +241,43 @@ check_ar9() { # **照样编译通过、测试照样全绿**,只有到 M2 那天才炸 ⇒ 那时候已经改了一堆东西, # 回滚成本高得多。⇒ 现在就把它拦住。 # -# 判据:`src/backend/src/platform/**`(**不含 compat/**)里不许出现 -# `crate::platform::compat` / `super::compat` / `crate::compat`。 +# 判据:平台层真源(`crates/sspf-core/src/**`)与转发壳(`src/backend/src/platform/**`, +# **不含 compat/**)里都不许出现 `crate::platform::compat` / `super::compat` / `crate::compat`。 check_ar10() { - local dir="$KERNEL/src/platform" - [ -d "$dir" ] || { skip "AR10 平台层目录不存在"; return; } + local dirs=() + [ -d "$CRATES/sspf-core/src" ] && dirs+=("$CRATES/sspf-core/src") + [ -d "$KERNEL/src/platform" ] && dirs+=("$KERNEL/src/platform") + [ "${#dirs[@]}" -gt 0 ] || { skip "AR10 平台层目录不存在"; return; } local hits # 🔴 **必须排除注释行**(`//` / `//!` / `///`)—— 文档注释里的路径引用是 # **给人看的**(如 `//! (见 crate::platform::compat::helper::load_menus])`), # 不是依赖 ⇒ 不该判红。 # 🔴 纯 grep 过滤不了:`//!` 前面**没有空格** ⇒ `^\s*//` 漏掉它。 # 这里用 python3 逐行判(与 MEM1/MEM2 同一套路)。 - hits="$(python3 - "$dir" <<'PY' + hits="$(python3 - "${dirs[@]}" <<'PY' import os, re, sys -root = sys.argv[1] pat = re.compile(r'(crate::platform::compat|crate::compat|super::compat)') bad = [] -for dirpath, dirnames, files in os.walk(root): - dirnames[:] = [d for d in dirnames if d != 'compat'] # 契约面自己互引合法 - for fn in files: - if not fn.endswith('.rs'): - continue - p = os.path.join(dirpath, fn) - try: - lines = open(p, encoding='utf-8').read().splitlines() - except OSError: - continue - for i, line in enumerate(lines, 1): - s = line.strip() - # 整行注释(含 `//!` / `///`)⇒ 跳过 - if s.startswith('//'): +for root in sys.argv[1:]: + for dirpath, dirnames, files in os.walk(root): + dirnames[:] = [d for d in dirnames if d != 'compat'] # 契约面自己互引合法 + for fn in files: + if not fn.endswith('.rs'): continue - # 行尾注释:把 `//` 之后截掉再判(`use x::y; // 说明` 里的说明不算) - code = line.split('//', 1)[0] - if pat.search(code): - bad.append(f'{p}:{i}: {s}') + p = os.path.join(dirpath, fn) + try: + lines = open(p, encoding='utf-8').read().splitlines() + except OSError: + continue + for i, line in enumerate(lines, 1): + s = line.strip() + # 整行注释(含 `//!` / `///`)⇒ 跳过 + if s.startswith('//'): + continue + # 行尾注释:把 `//` 之后截掉再判(`use x::y; // 说明` 里的说明不算) + code = line.split('//', 1)[0] + if pat.search(code): + bad.append(f'{p}:{i}: {s}') for b in bad: print(b) PY @@ -466,26 +475,40 @@ TOML echo "── 反自证 2/6:往平台层塞一个 use sspf_pack_*,AR9 必须报 ❌ ──" # - # 🔴 **为什么必须自证 AR9**:它的判据是 `grep platform/`。 + # 🔴 **为什么必须自证 AR9**:它的判据是 `grep 目录`。 # 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"**。 # 这类尺子比没有更危险(它给出虚假的安全感)。 - local probe="$KERNEL/src/platform/__ar9_selftest.rs" - if [ -d "$KERNEL/src/platform" ]; then - printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$probe" - before=$FAIL - check_ar9 >/dev/null 2>&1 - caught=0 - [ "$FAIL" -gt "$before" ] && caught=1 - rm -f "$probe" - FAIL=$before - if [ "$caught" -eq 1 ]; then - echo "✅ 反自证通过:AR9 抓到了平台层里的 use sspf_pack_*" - else - echo "❌ 反自证失败:AR9 没抓到平台层里的业务包引用 ⇒ 尺子是假的" - rc=1 + # 🔴 **M2 起必须注入两处**:真源 `crates/sspf-core/src/`(实现所在) + # + 转发壳 `src/backend/src/platform/`。**只注入一处不够** —— + # 若闸门只扫壳不扫真源(或反之),单点注入会漏判 ⇒ 两处都注入、 + # 且**两处都被抓到**才算尺子有效。 + local a9core="$CRATES/sspf-core/src/__ar9_selftest.rs" + local a9shell="$KERNEL/src/platform/__ar9_selftest.rs" + local a9ok=0 + if [ -d "$CRATES/sspf-core/src" ] || [ -d "$KERNEL/src/platform" ]; then + [ -d "$CRATES/sspf-core/src" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9core" + [ -d "$KERNEL/src/platform" ] && printf 'use sspf_pack_asset::DATA_RESOURCE_SPEC;\n' > "$a9shell" + local a9out + a9out="$(check_ar9 2>&1 || true)" + rm -f "$a9core" "$a9shell" + # 🔴 **按路径分别验**:必须证明闸门**两处都看得到** —— + # 只验「输出里有 __ar9_selftest」不够(单处抓到会误判成两处都抓到)。 + local a9need=0 a9c=0 + if [ -d "$CRATES/sspf-core/src" ]; then + a9need=$((a9need+1)) + echo "$a9out" | grep -q "sspf-core/src/__ar9_selftest" && a9c=$((a9c+1)) fi + if [ -d "$KERNEL/src/platform" ]; then + a9need=$((a9need+1)) + echo "$a9out" | grep -q "platform/__ar9_selftest" && a9c=$((a9c+1)) + fi + [ "$a9need" -gt 0 ] && [ "$a9c" -ge "$a9need" ] && a9ok=1 + fi + if [ "$a9ok" -eq 1 ]; then + echo "✅ 反自证通过:AR9 抓到了真源与转发壳里的 use sspf_pack_*" else - echo "⏭ 跳过 AR9 反自证(平台层目录不存在)" + echo "❌ 反自证失败:AR9 没抓到平台层里的业务包引用(或漏扫了真源/转发壳)⇒ 尺子是假的" + rc=1 fi echo "── 反自证 3/6:往 re-export 的模块里塞一份 spec,PACK1 必须报 ❌ ──" @@ -537,26 +560,35 @@ RS echo "── 反自证 5/6:往平台层塞 crate::platform::compat,AR10 必须报 ❌ ──" # - # 🔴 **必须自证 AR10**:它的判据是 `grep platform/`。 - # 目录名写错 / 路径拼错 ⇒ `grep` 永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。 - # 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,M2 当天才炸。 - local a10probe="$KERNEL/src/platform/__ar10_selftest.rs" - if [ -d "$KERNEL/src/platform" ]; then - printf 'use crate::platform::compat::helper::current_user;\n' > "$a10probe" - before=$FAIL - check_ar10 >/dev/null 2>&1 - caught=0 - [ "$FAIL" -gt "$before" ] && caught=1 - rm -f "$a10probe" - FAIL=$before - if [ "$caught" -eq 1 ]; then - echo "✅ 反自证通过:AR10 抓到了平台层里的 crate::platform::compat" - else - echo "❌ 反自证失败:AR10 没抓到平台层的契约面反向依赖 ⇒ 尺子是假的" - rc=1 + # 🔴 **必须自证 AR10**:它的判据是「扫平台层目录找契约面引用」。 + # 目录名写错 / 路径拼错 ⇒ 扫描永远返回空 ⇒ **永远"通过"** ⇒ 虚假安全感。 + # 而且这条判据守护的是**拆 crate 的前置条件** —— 它一旦失效,后续批次才炸。 + # 🔴 **M2 起注入两处**(真源 + 转发壳),与 2/6 同理:单点注入会漏判。 + local a10core="$CRATES/sspf-core/src/__ar10_selftest.rs" + local a10shell="$KERNEL/src/platform/__ar10_selftest.rs" + local a10ok=0 + if [ -d "$CRATES/sspf-core/src" ] || [ -d "$KERNEL/src/platform" ]; then + [ -d "$CRATES/sspf-core/src" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10core" + [ -d "$KERNEL/src/platform" ] && printf 'use crate::platform::compat::helper::current_user;\n' > "$a10shell" + local a10out + a10out="$(check_ar10 2>&1 || true)" + rm -f "$a10core" "$a10shell" + local a10need=0 a10c=0 + if [ -d "$CRATES/sspf-core/src" ]; then + a10need=$((a10need+1)) + echo "$a10out" | grep -q "sspf-core/src/__ar10_selftest" && a10c=$((a10c+1)) fi + if [ -d "$KERNEL/src/platform" ]; then + a10need=$((a10need+1)) + echo "$a10out" | grep -q "platform/__ar10_selftest" && a10c=$((a10c+1)) + fi + [ "$a10need" -gt 0 ] && [ "$a10c" -ge "$a10need" ] && a10ok=1 + fi + if [ "$a10ok" -eq 1 ]; then + echo "✅ 反自证通过:AR10 抓到了真源与转发壳里的 crate::platform::compat" else - echo "⏭ 跳过 AR10 反自证(平台层目录不存在)" + echo "❌ 反自证失败:AR10 没抓到平台层的契约面反向依赖(或漏扫了真源/转发壳)⇒ 尺子是假的" + rc=1 fi echo "── 反自证 6/6:往契约面底座塞 use super::system,AR11 必须报 ❌ ──" diff --git a/scripts/check-boundary.sh b/scripts/check-boundary.sh index b9bfd10..600b89f 100755 --- a/scripts/check-boundary.sh +++ b/scripts/check-boundary.sh @@ -38,6 +38,10 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd)" BACKEND="$ROOT/src/backend" SRC="$BACKEND/src" PLATFORM="$SRC/platform" +# 🔴 **M2 起平台层真源在 `crates/sspf-core/src/`**,`src/backend/src/platform/` +# 只剩转发壳(`pub use sspf_core::*`)+ 尚未搬走的 `compat/`(M3/M4)。 +# ⇒ 所有「扫平台层」的判据必须**两处都扫**(真源管实现、壳防塞私货)。 +PLATFORM_CORE="$ROOT/crates/sspf-core/src" MODULES="$SRC/modules" MODULES_MOD="$MODULES/mod.rs" BOOTSTRAP="$SRC/bootstrap.rs" @@ -110,7 +114,8 @@ hdr "[CP1] 平台层零业务标识符(扫字符串字面量;禁止清单从 # 🔴 **业务层现在有两处**(批次 12 交付物 ②):`modules/*.rs`(面 A 内嵌) # + `packs/*/src/lib.rs`(业务包)⇒ 两处都要进「禁止清单」, # 否则包里的业务表名会从清单里消失 ⇒ 尺子变弱。 -SCAN_OUT="$(SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" "${SCAN}" "${MODULES}" "${PLATFORM}" "${SRC}/routes.rs" "${SRC}/main.rs" "${BOOTSTRAP}" 2>&1)" +# 🔴 **M2 起平台层真源在 `crates/sspf-core/src/`** ⇒ 它必须进扫描面(否则扫空壳)。 +SCAN_OUT="$(SSW_PACKS_DIR="${ROOT}/packs" "${PY_BIN}" "${SCAN}" "${MODULES}" "${PLATFORM_CORE}" "${PLATFORM}" "${SRC}/routes.rs" "${SRC}/main.rs" "${BOOTSTRAP}" 2>&1)" if [ "$?" -eq 0 ]; then ok "平台层没有业务标识符($(printf '%s\n' "${SCAN_OUT}" | tail -1))" else @@ -119,12 +124,13 @@ else fi # ---- CP2 平台层不反向依赖业务层 ---- -hdr "[CP2] 平台层不反向依赖业务层(platform/** 不许 use crate::modules)" -CP2_HITS="$(grep -rn "use crate::modules" "${PLATFORM}" 2>/dev/null)" +hdr "[CP2] 平台层不反向依赖业务层(sspf-core/** 与 platform/** 不许 use crate::modules)" +# 🔴 两处都扫:真源 `crates/sspf-core/src/`(实现)+ 转发壳(防塞私货)。 +CP2_HITS="$(grep -rn "use crate::modules" "${PLATFORM_CORE}" "${PLATFORM}" 2>/dev/null)" if [ -z "${CP2_HITS}" ]; then - ok "platform/** 没有 use crate::modules" + ok "sspf-core/** 与 platform/** 都没有 use crate::modules" else - no "platform/** 引用了业务层:" + no "平台层引用了业务层:" printf '%s\n' "${CP2_HITS}" | sed 's/^/ /' fi @@ -223,24 +229,27 @@ else fi # ---- CP6 平台层自带菜单:条数与 id 都由**契约**推出来 ---- -hdr "[CP6] 平台层自带菜单(条数与 id 都由契约 [MENU] 推出来;业务菜单不许混进 platform/seed.rs)" +hdr "[CP6] 平台层自带菜单(条数与 id 都由契约 [MENU] 推出来;业务菜单不许混进 seed.rs)" +# 🔴 M2 起 `seed.rs` 真源在 `crates/sspf-core/src/seed.rs`(转发壳里没有 BUILTIN_MENUS)。 +SEED_RS="${PLATFORM_CORE}/seed.rs" +[ -f "${SEED_RS}" ] || SEED_RS="${PLATFORM}/seed.rs" PLATFORM_MENU_COUNT="$(awk ' /const BUILTIN_MENUS: \[MenuSpec; / { inb = 1; next } inb && /^\];/ { inb = 0; next } inb && /^[[:space:]]*id: "/ { n++ } END { print n + 0 } -' "${PLATFORM}/seed.rs")" +' "${SEED_RS}")" if [ "${PLATFORM_MENU_COUNT}" -eq "${CE_EXP_PLATFORM_MENUS}" ]; then - ok "platform/seed.rs 的 BUILTIN_MENUS 恰好 ${CE_EXP_PLATFORM_MENUS} 条系统菜单(契约菜单 ${CE_MENU_COUNT} 条 − 业务模块 ${CE_MOD_COUNT} 个)" + ok "seed.rs 的 BUILTIN_MENUS 恰好 ${CE_EXP_PLATFORM_MENUS} 条系统菜单(契约菜单 ${CE_MENU_COUNT} 条 − 业务模块 ${CE_MOD_COUNT} 个)" else - no "platform/seed.rs 的 BUILTIN_MENUS 有 ${PLATFORM_MENU_COUNT} 条(契约推出应为 ${CE_EXP_PLATFORM_MENUS} 条 = 契约菜单 ${CE_MENU_COUNT} − 业务模块 ${CE_MOD_COUNT})" + no "seed.rs 的 BUILTIN_MENUS 有 ${PLATFORM_MENU_COUNT} 条(契约推出应为 ${CE_EXP_PLATFORM_MENUS} 条 = 契约菜单 ${CE_MENU_COUNT} − 业务模块 ${CE_MOD_COUNT})" fi # 平台层那几条的 id,必须**逐条**等于契约 [MENU] 里「不属于任何业务模块」的那些 id PLATFORM_MENU_IDS="$(awk ' /const BUILTIN_MENUS: \[MenuSpec; / { inb = 1; next } inb && /^\];/ { inb = 0; next } inb && /^[[:space:]]*id: "/ { s = $0; sub(/^[ \t]*id: "/, "", s); sub(/".*/, "", s); print s } -' "${PLATFORM}/seed.rs" | sort | tr '\n' ' ')" +' "${SEED_RS}" | sort | tr '\n' ' ')" CE_PLATFORM_MENU_IDS="$(printf '%s\n' "${CE_MENU_ROWS}" | awk -F'\t' -v biz="${CE_BUSINESS_MENU_IDS}" ' NR > 1 { skip = 0 diff --git a/scripts/check-contract-scan.py b/scripts/check-contract-scan.py index 4a16e91..d6aff6f 100644 --- a/scripts/check-contract-scan.py +++ b/scripts/check-contract-scan.py @@ -826,12 +826,32 @@ def scan_code(src_dir, packs_dir=None): plat_dir = os.path.join(src_dir, "platform") plat_files = {"__routes__": (plat_orig, plat_masked)} - if os.path.isdir(plat_dir): - for name in sorted(os.listdir(plat_dir)): - if name.endswith(".rs"): - p = os.path.join(plat_dir, name) - o = read(p) - plat_files[name[:-3]] = (o, mask_rust(o)) + + def _absorb(key, o): + """把一个源文件收进 plat_files;重名键**拼接**(而非覆盖)。 + + 🔴 **为什么拼接**:M2 起平台层有两处 —— 真源 `crates/sspf-core/src/` + (实现)与转发壳 `platform/<模块>.rs`(`pub use sspf_core::*`)。 + 守卫推导按模块名查 `plat_files[mod]`;若后扫的覆盖先扫的, + 一边的函数就**推不出守卫** ⇒ CC6 退化成「全是 WARN」⇒ 静默失效。 + 拼接 ⇒ 两处定义的函数都看得见(壳里若有私货也逃不掉)。 + """ + m = mask_rust(o) + if key in plat_files: + o0, m0 = plat_files[key] + plat_files[key] = (o0 + "\n" + o, m0 + "\n" + m) + else: + plat_files[key] = (o, m) + + # 🔴 **平台层真源**(M2):`crates/sspf-core/src/<模块>.rs` —— + # 实现都搬到这里,守卫推导必须扫它(否则推不出 ⇒ CC6 静默失效)。 + core_dir = os.path.join(ROOT, "crates", "sspf-core", "src") + for d in (core_dir, plat_dir): + if os.path.isdir(d): + for name in sorted(os.listdir(d)): + if name.endswith(".rs"): + p = os.path.join(d, name) + _absorb(name[:-3], read(p)) # 🔴 **契约面实现文件**(批次 17 补):`platform/compat/<模块>.rs` —— # 契约面按官方模块名分文件(`online_dev.rs` / `report.rs` / `system.rs` …), # 路由注册写 `compat::<模块>::` ⇒ 这些文件**必须**进 `plat_files`, diff --git a/scripts/check-module.sh b/scripts/check-module.sh index 7b37396..bd4e086 100755 --- a/scripts/check-module.sh +++ b/scripts/check-module.sh @@ -43,7 +43,10 @@ MODULES_DIR="$BACKEND/src/modules" MODULES_MOD="$MODULES_DIR/mod.rs" ROUTES="$BACKEND/src/routes.rs" SCHEMA="$BACKEND/db/schema.sql" -CRUD="$BACKEND/src/platform/crud.rs" +# 🔴 **M2 起 `crud.rs` 真源在 `crates/sspf-core/src/crud.rs`**(转发壳里没有 SQL)。 +# 软删契约(`WHERE f_delete_mark = 0` / `SET f_delete_mark = 1`)必须读实现文件。 +CRUD="$ROOT/crates/sspf-core/src/crud.rs" +[ -f "$CRUD" ] || CRUD="$BACKEND/src/platform/crud.rs" FE="$ROOT/src/frontend" # 🔴 **本仓是后端-only**(CLAUDE.md §2.2:前端/移动端本期不动,沿用 Java 版)。 diff --git a/scripts/gen-function-catalog.py b/scripts/gen-function-catalog.py index cce33c0..a550b9d 100644 --- a/scripts/gen-function-catalog.py +++ b/scripts/gen-function-catalog.py @@ -9,7 +9,7 @@ ① 漏条 —— 前端某个函数在帮助里点不开,但没人发现; ② 抄错 HTML 描述 —— 帮助面板显示成乱码/错行,且没有闸门能发现。 -所以:**官方枚举是唯一真源**,本脚本把它转成 `src/backend/src/platform/variate_catalog.rs`。 +所以:**官方枚举是唯一真源**,本脚本把它转成 `crates/sspf-core/src/variate_catalog.rs`。 改了官方枚举就重跑;`--check` 用于闸门(生成物与真源不一致 ⇒ 非零退出)。 用法 @@ -31,7 +31,9 @@ JAVA_DIR = pathlib.Path( "/Users/xs/Desktop/workspace/jnpf/jnpf-java-boot/jnpf-system/" "jnpf-system-entity/src/main/java/jnpf/base/model/variate" ) -OUT = ROOT / "src" / "backend" / "src" / "platform" / "variate_catalog.rs" +# 🔴 **M2 起生成物的真源在 `crates/sspf-core/src/variate_catalog.rs`** —— +# 写旧路径会**覆盖转发壳**(`pub use sspf_core::*`)⇒ 上层 import 全断。 +OUT = ROOT / "crates" / "sspf-core" / "src" / "variate_catalog.rs" def read(path: pathlib.Path) -> str: diff --git a/src/backend/Cargo.toml b/src/backend/Cargo.toml index 6625df3..bd1125c 100644 --- a/src/backend/Cargo.toml +++ b/src/backend/Cargo.toml @@ -41,6 +41,10 @@ sspf-contract = { path = "../../crates/sspf-contract" } # 存储层(db / config)—— 不认识 HTTP,可被低代码引擎、CLI、MCP 适配器共用 sspf-store = { path = "../../crates/sspf-store" } +# 🔴 **平台核心层**(M2)—— 契约实现(信封 / cipher / 登录 / 权限 / base_* 管理 / CRUD 引擎)。 +# `src/backend/src/platform/*.rs` 现在只是转发壳(`pub use sspf_core::*`)⇒ 上层零感知。 +sspf-core = { path = "../../crates/sspf-core" } + # MCP 工具层(元工具 + 分层加载)—— 内核实现它的 PlatformAdapter,反向依赖 sspf-mcp = { path = "../../crates/sspf-mcp" } # 低代码元数据引擎(纯计算:解析/校验/SQL 生成) diff --git a/src/backend/src/platform/auth.rs b/src/backend/src/platform/auth.rs index b59b684..83b29e7 100644 --- a/src/backend/src/platform/auth.rs +++ b/src/backend/src/platform/auth.rs @@ -1,445 +1,5 @@ -//! auth —— 登录(`/api/oauth/Login`)、当前用户(`/api/oauth/CurrentUser`)与两个请求守卫。 -//! -//! 契约:规格 §6.1(认证)+ §9(`auth.rs` 接口)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/auth/`。 -//! -//! 🔴 **三条硬约定**: -//! 1. **业务失败恒 HTTP 200**:登录失败 `code=400`、未登录 `code=600`、无菜单权限 `code=403` -//! —— 全都是**信封里的 code**,不是 HTTP 状态码(**别抄 `tdc-rs` 的裸 401/403**)。 -//! 2. **表单解析失败也要走业务信封**:axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` -//! ⇒ `Option>` 编译不过 ⇒ 登录端点取**原始 body** 自己解析, -//! 解析失败返回 `fail(400, "缺少 account / password")`,**不是** axum 默认的 400 文本。 -//! 3. **口令不得外泄**:请求体里的密文只在内存里比对,响应体里**永不**回显; -//! 库里存的是 `md5(明文)`(`base_user.f_password`)。 +//! auth —— **转发壳**:真源在 [`sspf_core::auth`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use axum::body::Bytes; -use axum::extract::State; -use axum::http::HeaderMap; -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::authorization::{build_menu_list, has_module}; -use crate::platform::session::TokenUser; -use crate::platform::state::AppState; -use crate::platform::registry; - -/// token 有效期(秒)—— 契约 §6.1:恒为 `7200`。 -const TOKEN_EXPIRES_IN: i64 = 7200; - -/// 登录成功体里的 `tokenTypeName` —— 契约 §6.1:恒为 `"bearer"`。 -const TOKEN_TYPE_NAME: &str = "bearer"; - -/// 登录表单(**form-urlencoded**)。 -/// -/// 🔴 三个字段全是 `Option`:缺字段也要走**业务信封**(`code=400`), -/// 不能落到 axum 默认的 400 文本。 -/// 🔴 `grant_type` 是 **snake_case 字面量**(协议规定),**不能**改成 camelCase。 -/// 🔴 **不派生 `Debug`**:本结构体携带**口令密文**,一次 `{:?}` 就把密文打进日志。 -#[derive(serde::Deserialize)] -pub struct LoginForm { - /// 登录账号。 - pub account: Option, - /// 口令**密文**(hex)。 - pub password: Option, - /// 授权类型(`password`;可缺省)。 - pub grant_type: Option, -} - -/// 登录(契约 §6.1)。 -/// -/// 校验顺序(**不可换**,规格 §6.1 + brief S14): -/// 1. `account` 或 `password` 为空 ⇒ `fail(400, "缺少 account / password")`; -/// 2. `grant_type` **非空**且 ≠ `password` ⇒ `fail(400, "不支持的 grant_type")`; -/// 3. 账号不存在 / 已软删 / 口令不等 / **密文非法** ⇒ `fail(400, "账号或密码错误")`。 -/// -/// 🔴 密文非法(`decrypt_to_md5` 返回 `None`)与「口令错」是**同一条消息** -/// (react 的 `decryptToMd5` 失败返空串 ⇒ 比对不等 ⇒ 同一分支)⇒ 不另造文案。 -/// -/// 🔴 口令比对**大小写不敏感**(两边都转小写再比)。 -/// 🔴 查用户**只比未软删的行**(`f_delete_mark = 0`)。 -pub async fn login(state: &AppState, body: LoginForm) -> Json { - let account = body.account.unwrap_or_default(); - let encrypted = body.password.unwrap_or_default(); - - // ---- 序 1:缺 account / password ---- - if account.is_empty() || encrypted.is_empty() { - return fail(400, "缺少 account / password"); - } - - // ---- 序 2:grant_type 不支持 ---- - // 🔴 `grant_type` **缺失是允许的**;空串按「未设置」处理(与 react 的 falsy 判定一致)。 - if let Some(grant_type) = body.grant_type.as_deref() { - if !grant_type.is_empty() && grant_type != "password" { - return fail(400, "不支持的 grant_type"); - } - } - - // ---- 序 3:查用户(只比未软删的)---- - let rows = match state - .db - .query_json_params( - "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"storedPassword\", \ - f_is_administrator AS \"isAdministrator\" \ - FROM base_user WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&account], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - // 🔴 契约 §R1.2 / §6.5:DB 报错 ⇒ `系统异常,请联系管理员` - // (**不是**「账号或密码错误」—— DB 挂了不该伪装成口令错: - // 用户会反复重试,运维也看不到告警信号;两条消息必须能区分)。 - // 真因只进服务端日志,**不外泄**。 - eprintln!("[auth] 查询用户失败: {e}"); - return fail(400, "系统异常,请联系管理员"); - } - }; - - let Some(row) = rows.first() else { - // 账号不存在(或已软删)。 - return fail(400, "账号或密码错误"); - }; - - // 库内存的是 `md5(明文)`;密文解出来也是 `md5(明文)` ⇒ 直接比。 - // 🔴 `f_password` 可能是 NULL(官方 DDL 允许)⇒ 视为不匹配。 - // 🔴 JSON 键叫 `storedPassword`(**不叫 `password`**):免得有人一次 - // `println!("{row:?}")` 就把口令哈希打进日志。 - let stored = row.get("storedPassword").and_then(Value::as_str).unwrap_or(""); - let plain_md5 = match decrypt_to_md5(&encrypted) { - Some(md5) => md5, - // 🔴 密文非法(非法 hex / 非法 PKCS7 填充)⇒ **同一条**「账号或密码错误」。 - None => return fail(400, "账号或密码错误"), - }; - if stored.is_empty() || stored.to_lowercase() != plain_md5.to_lowercase() { - return fail(400, "账号或密码错误"); - } - - let user_id = row.get("id").and_then(Value::as_str).unwrap_or("").to_string(); - let account = row - .get("account") - .and_then(Value::as_str) - .unwrap_or(account.as_str()) - .to_string(); - let is_admin = row - .get("isAdministrator") - .and_then(Value::as_i64) - .and_then(|v| i32::try_from(v).ok()) - .unwrap_or(0); - - let token = state.sessions.issue(&account, &user_id, is_admin); - ok(json!({ - "token": token, - "expiresIn": TOKEN_EXPIRES_IN, - "tokenTypeName": TOKEN_TYPE_NAME, - })) -} - -/// 登录端点的**原始 body** 版本(契约 §6.1 的实现注记)。 -/// -/// 🔴 axum 0.8.9 的 `Form` 没有 `OptionalFromRequest` ⇒ `Option>` 编译不过 -/// ⇒ 这里自己用 `serde_urlencoded` 解析。 -/// 🔴 **解析失败也走业务信封**(`fail(400, "缺少 account / password")`), -/// 绝不能让 axum 返默认的 400 文本(前端拿到的是 HTML/纯文本,不是 `{code,msg,data}`)。 -pub async fn login_from_bytes(state: &AppState, body: Bytes) -> Json { - let form = match serde_urlencoded::from_bytes::(&body) { - Ok(form) => form, - Err(_) => return fail(400, "缺少 account / password"), - }; - login(state, form).await -} - -/// axum handler(`POST /api/oauth/Login`)—— Task 10 装配路由时直接用它。 -/// -/// 🔴 比 [`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; - // 🔴 登录成功 ⇒ 把**本次请求的 IP / UA** 补记到刚签发的会话上(在线用户页要显示)。 - // 只在真实 HTTP 路径走这一段:直接调 `login_from_bytes` 的测试没有头可记。 - if resp.0.code == 200 { - if let Some(token) = resp.0.data.get("token").and_then(Value::as_str) { - let ua = headers - .get(axum::http::header::USER_AGENT) - .and_then(|v| v.to_str().ok()) - .unwrap_or(""); - state.sessions.annotate(token, &client_ip(&headers), ua); - } - } - // 🔴 只在**有账号**时记账(连账号都没带 ⇒ 不是一次「登录尝试」,记账只会灌垃圾)。 - 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`,最后回环地址。 -pub(crate) 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` 解析成同一组枚举)—— -/// 页面这两列只是给人看的,分不出就写「其他」,绝不返空串(空串看起来像数据丢了)。 -pub(crate) 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)—— **面 A 形状**。 -/// -/// - 未登录 ⇒ `fail(600, "未登录")`; -/// - 成功 ⇒ `data = {"userInfo": {...}, "menuList": [...]}`。 -/// -/// 🔴 `userName` = **账号**(不是 `realName`);`isAdministrator` 是 **JSON 布尔**。 -/// -/// 🔴 **面 B 分流不在本函数里做** —— 分流点在上层的**装配根**(`routes.rs`): -/// 请求头带 `Vue-Version: 3` ⇒ 走**官方 `PcUserVO` 形状** -/// (`JNPF_COMPAT_SURFACE.md` §3.1);否则走本函数的面 A 形状。 -/// -/// 🔴 **为什么不在这里分流**(M1 解耦的根因):面 B 的形状组装住在契约面 -/// (`compat::helper::current_user`)。若在这里 `if is_face_b { compat::… }`, -/// 平台层就**反向依赖契约面** ⇒ 拆 crate 时是**循环依赖**,编译器直接报错。 -/// 分流点上移到装配根 ⇒ 平台层与契约面**互不知道对方**,壳负责接线。 -/// (与 `CLAUDE.md` §4「共用两条路由按判别头分流」是同一处设计。) -pub async fn current_user(state: &AppState, headers: HeaderMap) -> Json { - let Some(user) = resolve_user(state, &headers) else { - return fail(600, "未登录"); - }; - - // 🔴 多应用:按 `App-Code` 解析当前系统 ⇒ 菜单树与守卫都按该系统隔离。 - let sys = registry::resolve_system(&state.db, registry::app_code_of(&headers).as_deref()).await; - let menu_list = build_menu_list(&state.db, &user.user_id, user.is_admin, &sys.id).await; - - ok(json!({ - "userInfo": { - "userId": user.user_id, - "userAccount": user.account, - "userName": user.account, - "isAdministrator": user.is_admin == 1, - "systemId": sys.id, - "systemCode": sys.code, - }, - "menuList": menu_list, - "currentSystemId": sys.id, - })) -} - -/// 守卫:**未登录** ⇒ `Err(fail(600, "未登录"))`;已登录 ⇒ `Ok(TokenUser)`。 -/// -/// 🔴 失败也是 **HTTP 200** + `code=600`(不是 401)。 -pub async fn require_login( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - match resolve_user(state, headers) { - Some(user) => Ok(user), - None => Err(fail(600, "未登录")), - } -} - -/// 守卫(**面 B**):**未登录 / token 无效** ⇒ `Err(fail(602, …))`;已登录 ⇒ `Ok(TokenUser)`。 -/// -/// 🔴 **面 B 必须返 `602` 而不是 `600`** —— 官方前端 `request.ts:78-80` 只对 -/// `601`/`602`(`TOKEN_ERROR` / `TOKEN_LOGGED` / `TOKEN_TIMEOUT`)清 token -/// ⇒ 只返 `600` 会让页面**卡住不跳登录**(`JNPF_COMPAT_SURFACE.md` §4)。 -/// -/// 🔴 失败也**恒 HTTP 200**(信封里的 `code`),不是 HTTP 401。 -pub async fn require_login_face_b( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - match resolve_user(state, headers) { - Some(user) => Ok(user), - None => Err(fail( - crate::platform::envelope::code::SESSION_ERROR, - "登录状态已失效,请重新登录", - )), - } -} - -/// 守卫(**按面分流**):面 B(`Vue-Version: 3`)⇒ `602`;面 A ⇒ `600`。 -/// -/// 🔴 用在**两个面共用的路由**上(如 `PUT /api/permission/Authority/Data/{objectId}`): -/// 同一个「未登录」场景,**面 A 返 600、面 B 返 602**。 -pub async fn require_login_any( - state: &AppState, - headers: &HeaderMap, -) -> Result> { - // 🔴 同上:判据取契约层,不绕 compat(避免平台层 → 契约面的反向依赖)。 - if sspf_contract::headers::is_face_b(headers) { - require_login_face_b(state, headers).await - } else { - require_login(state, headers).await - } -} - -/// 守卫:**登录 + 菜单权限**。 -/// -/// 1. 先 `require_login`(未登录 ⇒ `600`); -/// 2. 再 `has_module(...)`;无权限 ⇒ `Err(fail(403, "无菜单权限"))`。 -/// -/// 🔴 **多应用**:按 `App-Code` 解析出的当前系统参与菜单守卫 ⇒ 应用间不串。 -/// -/// 🔴 失败也是 **HTTP 200** + `code=403`(不是 403 状态码)。 -pub async fn require_module( - state: &AppState, - headers: &HeaderMap, - module_key: &str, -) -> Result> { - let user = require_login(state, headers).await?; - let system_id = - registry::resolve_system_id(&state.db, registry::app_code_of(headers).as_deref()).await; - if has_module(&state.db, &user.user_id, user.is_admin, module_key, &system_id).await { - Ok(user) - } else { - Err(fail(403, "无菜单权限")) - } -} - -/// 从 `Authorization` 头解析出当前用户(无 / 非法 ⇒ `None`)。 -/// -/// 🔴 `pub` —— 面 B 的 `compat::helper` 也要用它(官方形状的 `CurrentUser`)。 -/// 拆 crate 后 compat 包要跨 crate 调它 ⇒ `pub(crate)` 会失效。 -/// 它**不泄密**:只从 `Authorization` 头取 token,解析失败返 `None`。 -pub fn resolve_user(state: &AppState, headers: &HeaderMap) -> Option { - let auth = headers.get("authorization")?; - let auth = auth.to_str().ok()?; - state.sessions.resolve(Some(auth)) -} +pub use sspf_core::auth::*; diff --git a/src/backend/src/platform/authorization.rs b/src/backend/src/platform/authorization.rs index 6efff47..76a3fbf 100644 --- a/src/backend/src/platform/authorization.rs +++ b/src/backend/src/platform/authorization.rs @@ -1,467 +1,5 @@ -//! authorization —— 四源权限合并 + 管理员短路 + 未映射放行 + 菜单树。 -//! -//! 契约:`docs/contract.md` §8.1(四源合并)/ §8.2(判定顺序)/ §8.3(菜单树)。 -//! -//! 🔴 **为什么叫 `authorization` 而不是 `permission`**:本仓的**契约面**按官方模块名 -//! 组织(`compat/permission.rs` = 官方面 B 的 permission 端点集)。平台机制这一层 -//! 要用**语义名**区分开 —— 它管的是「授权判定引擎」,不是「权限端点」。 -//! -//! 逐字对齐 react 参考实现 `ssw-jnpf-lite-react/src/backend/src/sys/permission.service.ts` -//! (`resolveUserModuleIds` / `hasModule` / `buildMenuList` / `toTree`)。 -//! -//! 🔴 **判定顺序不可换**(§8.2): -//! 1. `is_admin == 1` ⇒ 放行(**不查任何 SQL**); -//! 2. 查 `base_module`(`f_url_address = key AND f_delete_mark = 0`) -//! —— **查不到 ⇒ 放行**(未映射放行,对齐 `SswPermissionGuard` 的 warn 路径); -//! 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 -//! -//! 🔴 **DB 报错 ≠「未映射放行」**(契约 §9 的签名没有 `Result` ⇒ 错误只能内部消解, -//! 且消解方向必须是**拒**): -//! - 「查不到」= SQL 执行成功、结果集为空 ⇒ **放行**; -//! - 「查询失败」= DB 报错 ⇒ **拒**(`has_module` 返回 `false`)。 -//! 两条路径必须**分开写** —— 写成 `if !found { return true }` 会把「DB 挂了」变成 -//! 「放行一切」⇒ **全站越权**(且静默)。 -//! -//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` —— 用户标识在 -//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` **才有** -//! `f_user_id`。写错列 ⇒ 授权永远不生效且**静默**。 -//! -//! 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized` 只在 -//! 这一张表上加了 `deleteMark: 0`);`base_role_relation` / `base_user_relation` -//! **不过滤**软删 —— 照抄,不自作主张加过滤。 +//! authorization —— **转发壳**:真源在 [`sspf_core::authorization`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use std::collections::{HashMap, HashSet}; - -use serde::Serialize; - -use crate::platform::db::{pglite, pglite::ToSql, Db}; - -/// 菜单节点(契约 §8.3 的节点形状)。 -/// -/// 🔴 `url_address` / `icon` 为 `None` ⇒ 序列化成 `null`,**键仍在**(不省略)—— -/// 与 TypeORM 的 `nullable: true` 行为一致(内置的 `m_user` / `m_role` / `m_org` / -/// `m_menu` 的 `f_icon` 就是 NULL)。 -/// 🔴 `children` 恒存在(无子节点 ⇒ `[]`)。 -#[derive(Debug, Clone, Serialize)] -pub struct MenuNode { - /// 菜单 id(`base_module.f_id`)。 - pub id: String, - /// 菜单全名(`f_full_name`)。 - #[serde(rename = "fullName")] - pub full_name: String, - /// 前端 Route path(`f_url_address`)—— 可空。 - #[serde(rename = "urlAddress")] - pub url_address: Option, - /// 图标(`f_icon`)—— 可空。 - pub icon: Option, - /// 父菜单 id(`f_parent_id`)—— 空 ⇒ `'0'`。 - #[serde(rename = "parentId")] - pub parent_id: String, - /// 子菜单(按 `f_sort_code` 升序)。 - pub children: Vec, -} - -/// 一行菜单(内部用;`base_module` 的可见列)。 -struct MenuRow { - id: String, - full_name: String, - url_address: Option, - icon: Option, - parent_id: String, -} - -/// 菜单树的最大层数(防御 `f_parent_id` 被改成人为环时的无限递归)。 -/// -/// 🔴 **这是防御性上限,react 无此概念**(react 的 `toTree` 没有层数概念)—— -/// 契约 §8.3 对层数也无规定。截断只在「菜单嵌套 > 32 层」时生效, -/// 现实中不可达;不封顶则极深的链会让递归爆栈 ⇒ 整个进程死掉。 -const MAX_TREE_DEPTH: usize = 32; - -/// 四源合并(契约 §8.1)—— 用户可见的菜单 id 集合。 -/// -/// 四个来源: -/// 1. **直授**:`base_authorize`(`f_object_type='user'`); -/// 2. **角色**:`base_role_relation`(`f_object_type='user'`)⇒ `f_role_id` -/// ⇒ `base_authorize`(`f_object_type='role'`); -/// 3. **组织**:`base_user_relation`(`f_object_type='organize'`)⇒ `f_object_id` -/// ⇒ `base_authorize`(`f_object_type='organize'`); -/// 4. **岗位**:`base_user_relation`(`f_object_type='position'`)⇒ `f_object_id` -/// ⇒ `base_authorize`(`f_object_type='position'`)。 -/// -/// 🔴 **DB 报错 ⇒ 返回空集**(= 零授权,方向是「拒」),并 `eprintln!` 一行。 -/// 契约 §9 的签名没有 `Result` ⇒ 错误不能往外冒泡(否则会变成裸 HTTP 500)。 -pub async fn resolve_user_module_ids(db: &Db, user_id: &str) -> HashSet { - let mut ids: HashSet = HashSet::new(); - - // ---- 源 1:直授 ---- - if let Err(e) = add_authorized(db, &mut ids, "user", user_id).await { - eprintln!("[permission] 直授授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - - // ---- 源 2:角色 ---- - let role_ids = match query_user_role_ids(db, user_id).await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔角色关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for role_id in role_ids { - if let Err(e) = add_authorized(db, &mut ids, "role", &role_id).await { - eprintln!("[permission] 角色授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - // ---- 源 3:组织 ---- - let organize_ids = match query_user_relation_ids(db, user_id, "organize").await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔组织关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for organize_id in organize_ids { - if let Err(e) = add_authorized(db, &mut ids, "organize", &organize_id).await { - eprintln!("[permission] 组织授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - // ---- 源 4:岗位 ---- - let position_ids = match query_user_relation_ids(db, user_id, "position").await { - Ok(ids) => ids, - Err(e) => { - eprintln!("[permission] 用户↔岗位关系查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - }; - for position_id in position_ids { - if let Err(e) = add_authorized(db, &mut ids, "position", &position_id).await { - eprintln!("[permission] 岗位授权查询失败(按零授权处理): {e}"); - return HashSet::new(); - } - } - - ids -} - -/// 菜单守卫(契约 §8.2)—— 当前用户能否访问 `module_key` 对应的菜单。 -/// -/// 🔴 判定顺序**不可换**: -/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); -/// 2. 查 `base_module` —— **查不到 ⇒ `true`**(未映射放行); -/// 3. 查得到 ⇒ 菜单 id 是否在四源集合里。 -/// -/// 🔴 **多应用隔离**:`system_id` 把菜单查找限定在「当前应用」(`base_module.f_system_id`) -/// ⇒ 不同应用的同路径菜单互不串(`App-Code` 头路由到哪个应用,就按哪个应用判守卫)。 -/// -/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 -pub async fn has_module( - db: &Db, - user_id: &str, - is_admin: i32, - module_key: &str, - system_id: &str, -) -> bool { - // ---- 1) 管理员短路:在任何 SQL 之前 ---- - if is_admin == 1 { - return true; - } - - // ---- 2) 查菜单 ---- - let module_key = module_key.to_string(); - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_url_address = $1::text AND f_system_id = $2::text AND f_delete_mark = 0 LIMIT 1", - &[&module_key, &system_id], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - // 🔴 查询失败 ⇒ **拒**(不是「未映射」!) - eprintln!("[permission] 菜单查询失败(按拒绝处理): {e}"); - return false; - } - }; - // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 - let Some(row) = rows.first() else { - return true; - }; - let Some(module_id) = row["id"].as_str() else { - // 主键不该是 NULL;万一如此 ⇒ 保守拒绝。 - eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); - return false; - }; - - // ---- 3) 四源合并集合里有没有它 ---- - // (`resolve_user_module_ids` 出错 ⇒ 空集 ⇒ 这里自然是 `false`。) - resolve_user_module_ids(db, user_id).await.contains(module_id) -} - -/// **面 B 的点权限守卫** —— 当前用户能否访问 `f_en_code = en_code` 的菜单。 -/// -/// 🔴 这是**第二套判据**(面 A 用菜单路径 `f_url_address`;官方用 `f_en_code`), -/// 两者**并存**、互不影响(`JNPF_COMPAT_SURFACE.md` §3.2 / §7 S5)。 -/// 官方形态:`@SaCheckPermission("permission.user")` ⇒ 判「该用户是否持有 -/// `f_en_code='permission.user'` 的菜单授权」。 -/// -/// 🔴 **判定顺序与 [`has_module`] 逐字同构**(不可换): -/// 1. `is_admin == 1` ⇒ `true`(**不查任何 SQL**); -/// 2. 查 `base_module`(`f_en_code = $1 AND f_system_id = $2 AND f_delete_mark = 0`) -/// —— **查不到 ⇒ `true`**(未映射放行,与面 A 同一条红线); -/// 3. 查得到 ⇒ 该菜单 id 是否在四源合并集合里。 -/// -/// 🔴 **多应用隔离**:`system_id` 把点权限判据限定在「当前应用」⇒ 不同应用的同 en_code -/// 不会串(官方 `@SaCheckPermission` 也是按当前系统 `currentSystemId` 判)。 -/// -/// 🔴 **DB 报错 ⇒ `false`(拒)** —— 绝不返回 `true`(那会是全站越权)。 -pub async fn has_en_code_permission( - db: &Db, - user_id: &str, - is_admin: i32, - en_code: &str, - system_id: &str, -) -> bool { - // ---- 1) 管理员短路:在任何 SQL 之前 ---- - if is_admin == 1 { - return true; - } - - // ---- 2) 查菜单(按 `f_en_code`,且限定当前应用)---- - let en_code = en_code.to_string(); - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_en_code = $1::text AND f_system_id = $2::text AND f_delete_mark = 0 LIMIT 1", - &[&en_code, &system_id], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[permission] 菜单点权限查询失败(按拒绝处理): {e}"); - return false; - } - }; - // 「查不到」= 查询成功但没有这行 ⇒ 未映射放行(与上面的失败分支**必须分开**)。 - let Some(row) = rows.first() else { - return true; - }; - let Some(module_id) = row["id"].as_str() else { - eprintln!("[permission] 菜单行的 id 为空(按拒绝处理)"); - return false; - }; - - // ---- 3) 四源合并集合里有没有它 ---- - resolve_user_module_ids(db, user_id).await.contains(module_id) -} - -/// 当前用户可见的菜单树(契约 §8.3)。 -/// -/// - 取 `base_module` 中 `f_delete_mark = 0` 的行,按 `f_sort_code ASC`; -/// - 非管理员:过滤成「id 在四源集合里」的子集; -/// - 建树:`f_parent_id` 为空 / `'0'` / **父不在可见集合内** ⇒ 该节点是根; -/// 否则挂到父节点的 `children`。 -/// -/// 🔴 **DB 报错 ⇒ 返回空 `Vec`**(用户看不到任何入口,方向是「拒」)。 -/// -/// 🔴 **多应用隔离**:`system_id` 把菜单集合限定在「当前应用」(`base_module.f_system_id`) -/// ⇒ 不同应用各看各的菜单(官方 `App-Code` 选应用 ⇒ 菜单树随之切换)。 -pub async fn build_menu_list( - db: &Db, - user_id: &str, - is_admin: i32, - system_id: &str, -) -> Vec { - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\", \ - f_url_address AS \"urlAddress\", f_icon AS \"icon\", \ - f_parent_id AS \"parentId\" \ - FROM base_module WHERE f_delete_mark = 0 AND f_system_id = $1::text \ - ORDER BY f_sort_code ASC", - &[&system_id], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - eprintln!("[permission] 菜单列表查询失败(按空菜单处理): {e}"); - return Vec::new(); - } - }; - - let mut items: Vec = rows.iter().filter_map(parse_menu_row).collect(); - if is_admin != 1 { - let visible = resolve_user_module_ids(db, user_id).await; - items.retain(|m| visible.contains(&m.id)); - } - build_tree(items) -} - -/// 渲染单个菜单节点(**固定格式**,供菜单树断言逐字比对)。 -/// -/// 格式:`:` + 子节点的 `fullName` 用 `,` 连接 -/// (子节点若有子节点,其后代**不展开** —— 内置菜单最多两层,够用)。 -pub fn render(node: &MenuNode) -> String { - let kids: Vec = node.children.iter().map(|c| c.full_name.clone()).collect(); - format!("{}:{}", node.full_name, kids.join(",")) -} - -/// 渲染整棵菜单树(**固定格式**):根节点的渲染结果用 `|` 连接。 -pub fn render_tree(roots: &[MenuNode]) -> String { - roots.iter().map(render).collect::>().join("|") -} - -// ---- 内部实现 ---- - -/// 把某个对象(用户 / 角色 / 组织 / 岗位)的模块授权并进集合。 -/// -/// 🔴 **只有 `base_authorize` 过滤 `f_delete_mark = 0`**(react 的 `addAuthorized`)。 -async fn add_authorized( - db: &Db, - ids: &mut HashSet, - object_type: &str, - object_id: &str, -) -> Result<(), pglite::Error> { - let object_type = object_type.to_string(); - let object_id = object_id.to_string(); - let params: [&(dyn ToSql + Sync); 2] = [&object_type, &object_id]; - let rows = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = $1::text AND f_object_id = $2::text \ - AND f_item_type = 'module' AND f_delete_mark = 0", - ¶ms, - ) - .await?; - for row in rows { - if let Some(item_id) = row["itemId"].as_str() { - if !item_id.is_empty() { - ids.insert(item_id.to_string()); - } - } - } - Ok(()) -} - -/// 用户↔角色关系 ⇒ 角色 id 列表。 -/// -/// 🔴 `base_role_relation` **没有** `f_user_id` —— 用户标识在 `f_object_id` -/// (配 `f_object_type='user'`)。 -/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `roleRelRepo.find`)。 -async fn query_user_role_ids(db: &Db, user_id: &str) -> Result, pglite::Error> { - let user_id = user_id.to_string(); - let params: [&(dyn ToSql + Sync); 1] = [&user_id]; - let rows = db - .query_json_params( - "SELECT f_role_id AS \"roleId\" FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text", - ¶ms, - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["roleId"].as_str().map(str::to_string)) - .filter(|id| !id.is_empty()) - .collect()) -} - -/// 用户↔组织 / 岗位关系 ⇒ 对象 id 列表。 -/// -/// 🔴 `base_user_relation` **才有** `f_user_id`。 -/// 🔴 **不过滤** `f_delete_mark`(照抄 react 的 `userRelRepo.find`)。 -async fn query_user_relation_ids( - db: &Db, - user_id: &str, - object_type: &str, -) -> Result, pglite::Error> { - let user_id = user_id.to_string(); - let object_type = object_type.to_string(); - let params: [&(dyn ToSql + Sync); 2] = [&user_id, &object_type]; - let rows = db - .query_json_params( - "SELECT f_object_id AS \"objectId\" FROM base_user_relation \ - WHERE f_user_id = $1::text AND f_object_type = $2::text", - ¶ms, - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r["objectId"].as_str().map(str::to_string)) - .filter(|id| !id.is_empty()) - .collect()) -} - -/// 一行 JSON ⇒ [`MenuRow`](`f_full_name` / `f_parent_id` 为 NULL ⇒ 取默认值)。 -fn parse_menu_row(row: &serde_json::Value) -> Option { - let id = row["id"].as_str()?.to_string(); - if id.is_empty() { - return None; - } - Some(MenuRow { - id, - full_name: row["fullName"].as_str().unwrap_or_default().to_string(), - url_address: row["urlAddress"].as_str().map(str::to_string), - icon: row["icon"].as_str().map(str::to_string), - // 🔴 react: `parentId: m.parentId || '0'` —— 空 ⇒ `'0'`。 - parent_id: match row["parentId"].as_str() { - Some(p) if !p.is_empty() => p.to_string(), - _ => "0".to_string(), - }, - }) -} - -/// 建树(逐字对齐 react 的 `toTree`)。 -/// -/// 🔴 根的判定:`parentId` 非空 **且** `!== '0'` **且** 父在可见集合内 ⇒ 挂到父节点; -/// 否则(含**父不在集合内**)⇒ **自己就是根**(不是被丢弃)。 -fn build_tree(items: Vec) -> Vec { - let visible: HashSet = items.iter().map(|m| m.id.clone()).collect(); - - let mut by_parent: HashMap> = HashMap::new(); - let mut roots: Vec = Vec::new(); - for item in items { - if item.parent_id != "0" && visible.contains(&item.parent_id) { - by_parent.entry(item.parent_id.clone()).or_default().push(item); - } else { - roots.push(item); - } - } - - roots - .into_iter() - .map(|row| build_node(row, &mut by_parent, 0)) - .collect() -} - -/// 递归建一棵子树。 -fn build_node( - row: MenuRow, - by_parent: &mut HashMap>, - depth: usize, -) -> MenuNode { - // 防御:`f_parent_id` 被改成人为环时不要无限递归(层数封顶 ⇒ 截断)。 - let children = if depth >= MAX_TREE_DEPTH { - Vec::new() - } else { - by_parent - .remove(&row.id) - .unwrap_or_default() - .into_iter() - .map(|child| build_node(child, by_parent, depth + 1)) - .collect() - }; - MenuNode { - id: row.id, - full_name: row.full_name, - url_address: row.url_address, - icon: row.icon, - parent_id: row.parent_id, - children, - } -} +pub use sspf_core::authorization::*; diff --git a/src/backend/src/platform/cipher.rs b/src/backend/src/platform/cipher.rs index 01ccf43..10c5493 100644 --- a/src/backend/src/platform/cipher.rs +++ b/src/backend/src/platform/cipher.rs @@ -1,213 +1,5 @@ -//! cipher —— md5 + AES-256-ECB(与 react 版 cipher.ts 逐字节等价)。 -//! -//! 对齐物:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/common/cipher.ts` -//! -//! 契约(**不得改动**,见 `.superpowers/sdd/ssw-jnpf-lite-rust-v1/task-1-brief.md`): -//! 1. `key = md5_hex("EY8WePvjM5GGwQzn")` —— 把这 **32 个 ASCII 字节**当 key ⇒ **AES-256** -//! (⚠️ 不是 16 字节原始摘要;用 16 字节会退化成 AES-128 ⇒ 所有登录全挂) -//! 2. `src = md5_hex(plaintext)` 的 **32 个 ASCII 字节** -//! 3. `AES-256-ECB-PKCS7`,输出 hex(32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符) -//! -//! 🔴 **口令不得外泄**:本模块的输出只在**请求体**里出现(登录时前端传来的密文), -//! 永不在响应里回显。库里存的是 `md5(明文)`(`base_user.f_password`)。 +//! cipher —— **转发壳**:真源在 [`sspf_core::cipher`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use aes::cipher::{ - block_padding::Pkcs7, generic_array::GenericArray, BlockDecryptMut, BlockEncryptMut, KeyInit, -}; -use md5::{Digest, Md5}; - -/// AES-256-ECB 加密器(cipher 0.4 家族:`BlockEncryptMut` + `Pkcs7`)。 -type Aes256EcbEnc = ecb::Encryptor; -/// AES-256-ECB 解密器。 -type Aes256EcbDec = ecb::Decryptor; - -/// react 版 cipher.ts 里的 `CIPHER_KEY`。 -const CIPHER_KEY: &str = "EY8WePvjM5GGwQzn"; - -/// AES 分组长度(字节)。 -const BLOCK_SIZE: usize = 16; - -/// `md5(明文)` 的十六进制串(32 个字符)。 -/// -/// 与 react 版 `md5Hex` 等价:CryptoJS.MD5(str).toString() ⇒ 小写 hex。 -pub fn md5_hex(s: &str) -> String { - hex::encode(Md5::digest(s.as_bytes())) -} - -/// 派生出 AES-256 key:**32 个 ASCII 字节**(即 `md5_hex(CIPHER_KEY)` 这个 32 字符 hex 串本身)。 -fn cipher_key_bytes() -> [u8; 32] { - let key = md5_hex(CIPHER_KEY); - // `md5_hex` 恒为 32 个 ASCII 字符 ⇒ 长度必然是 32。 - let bytes = key.into_bytes(); - let mut out = [0u8; 32]; - out.copy_from_slice(&bytes); - out -} - -/// 登录密码加密:`md5(明文)` → AES-256-ECB-PKCS7 → hex。 -/// -/// 上游检验向量:`encrypt_password("123456")` == -/// `d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b` -/// (96 个 hex 字符 = 48 字节密文;**不是** 64 —— 漏了 PKCS7 填充就会输出 64)。 -pub fn encrypt_password(plain: &str) -> String { - // src = md5(明文) 的 32 个 ASCII 字节。 - let src = md5_hex(plain).into_bytes(); - debug_assert_eq!(src.len(), 32, "md5_hex 恒为 32 个 ASCII 字符"); - - // 32 字节明文 + PKCS7 补满一整块 ⇒ 48 字节密文。 - let mut buf = [0u8; 48]; - buf[..src.len()].copy_from_slice(&src); - - let key_bytes = cipher_key_bytes(); - // 🔴 `KeyInit::new` 是 cipher 0.4 的**不可失败**构造器(`new_from_slice` 内部 - // 就是 `Self::new(Key::from_slice(key))`,两者完全等价)⇒ 去掉 `expect`。 - let key = GenericArray::clone_from_slice(&key_bytes); - let enc = Aes256EcbEnc::new(&key); - let ct = match enc.encrypt_padded_mut::(&mut buf, src.len()) { - Ok(ct) => ct, - Err(_) => { - // 🔴 理论不可达:buf 48 字节、msg 32 字节,PKCS7 最多补 16 字节 ⇒ 放得下。 - // 真到了这里就 **fail closed**(返空串 ⇒ 下游 `decrypt_to_md5` 返 `None` - // ⇒ 登录走「账号或密码错误」),**绝不 panic**(panic 会打断 HTTP 连接)。 - // 🔴 **绝不回显明文/密文**(那是口令泄漏)。 - eprintln!("[cipher] PKCS7 填充失败(理论不可达)"); - return String::new(); - } - }; - hex::encode(ct) -} - -/// 解密前端加密串 → `md5(明文)`,用于登录比对。 -/// -/// 非法 hex / 长度不是分组整数倍 / PKCS7 填充不合法 ⇒ `None`。 -pub fn decrypt_to_md5(encrypted_hex: &str) -> Option { - let mut ct = hex::decode(encrypted_hex).ok()?; - if ct.is_empty() || ct.len() % BLOCK_SIZE != 0 { - return None; - } - - let key = cipher_key_bytes(); - let dec = Aes256EcbDec::new_from_slice(&key).ok()?; - let pt = dec.decrypt_padded_mut::(&mut ct).ok()?; - String::from_utf8(pt.to_vec()).ok() -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 上游(react 版 cipher.ts)检验向量 —— 逐字节相等才算通过。 - #[test] - fn encrypt_password_matches_upstream_vector() { - assert_eq!( - encrypt_password("123456"), - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ); - } - - /// 上游检验向量反向:上游密文解出来必须等于 `md5("123456")`。 - #[test] - fn decrypt_matches_upstream_vector() { - assert_eq!( - decrypt_to_md5( - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ), - Some(md5_hex("123456")) - ); - assert_eq!( - decrypt_to_md5( - "d4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b" - ), - Some("e10adc3949ba59abbe56e057f20f883e".to_string()) - ); - } - - /// 十六进制大小写都接受(前端 CryptoJS `Hex.parse` 产出小写,但别把大小写当契约)。 - #[test] - fn uppercase_hex_input_is_accepted() { - let lower = encrypt_password("123456"); - let upper = lower.to_uppercase(); - assert_ne!(lower, upper, "输入必须真的变成大写,否则这条断言是空转"); - assert_eq!(decrypt_to_md5(&upper), Some(md5_hex("123456"))); - } - - #[test] - fn md5_hex_of_empty_string() { - assert_eq!(md5_hex(""), "d41d8cd98f00b204e9800998ecf8427e"); - } - - #[test] - fn md5_hex_of_abc() { - assert_eq!(md5_hex("abc"), "900150983cd24fb0d6963f7d28e17f72"); - } - - #[test] - fn round_trip_returns_md5_of_plaintext() { - assert_eq!( - decrypt_to_md5(&encrypt_password("hunter2")), - Some(md5_hex("hunter2")) - ); - } - - #[test] - fn invalid_hex_yields_none() { - assert_eq!(decrypt_to_md5("not-hex!!"), None); - assert_eq!(decrypt_to_md5("zz"), None); - } - - /// 32 字节明文 ⇒ PKCS7 补满一整块 ⇒ 48 字节密文 ⇒ 96 个 hex 字符。 - #[test] - fn ciphertext_length_is_96_hex_chars() { - assert_eq!(encrypt_password("x").len(), 96); - // 空明文同样走 32 字节 md5,长度不变。 - assert_eq!(encrypt_password("").len(), 96); - } - - /// key 必须是 md5_hex(CIPHER_KEY) 的 **32 个 ASCII 字节** ⇒ AES-256,不是 AES-128。 - #[test] - fn key_is_32_ascii_bytes() { - let key = cipher_key_bytes(); - assert_eq!(key.len(), 32); - assert_eq!(std::str::from_utf8(&key).unwrap(), md5_hex(CIPHER_KEY)); - // 32 字节 key ⇒ AES-256(KeySize = U32)。 - assert!(Aes256EcbEnc::new_from_slice(&key).is_ok()); - } - - /// 长度不是分组整数倍 ⇒ None(解不开)。 - #[test] - fn wrong_length_ciphertext_yields_none() { - assert_eq!(decrypt_to_md5("00"), None); - assert_eq!(decrypt_to_md5(""), None); - } - - /// 规格 §3:**PKCS7 填充不合法 ⇒ `None`**(钉住 `block-padding 0.3.3` 的严格解填充)。 - /// - /// `block-padding-0.3.3/src/lib.rs:216-218` 的 `Pkcs7::raw_unpad` 传 `strict = true` - /// ⇒ 填充字节不全等于长度字节 n 时解填充失败 ⇒ `None`。 - /// - /// 构造(确定性,不靠概率):上游向量是 48 字节密文 = 32 字节明文 + **整块 16 字节填充** - /// ⇒ 最后一个密文块解出来是 16 个 `0x10`。ECB 无扩散 ⇒ 改**密文**的某字节, - /// 只改对应明文字节。 - #[test] - fn invalid_pkcs7_padding_yields_none() { - let good = encrypt_password("123456"); - let bytes = hex::decode(&good).unwrap(); - assert_eq!(bytes.len(), 48, "32 字节明文 + 整块 16 字节填充"); - - // ① 改填充块的**长度字节**(末字节):0x10 → 0x11(= 17 > 块长 16)⇒ 填充非法。 - let mut a = bytes.clone(); - a[47] ^= 0x01; - let corrupted_len_byte = hex::encode(&a); - assert_ne!(corrupted_len_byte, good); - assert_eq!(decrypt_to_md5(&corrupted_len_byte), None); - - // ② 改填充块**中间某个填充字节**(第 2 个):0x10 → 0x0f。 - // 长度字节仍是 0x10(= 16,合法范围),但填充字节不自洽 - // ⇒ **严格模式**才拒;宽松模式会照单全收 ⇒ 这条断言正是「严格性」的证据。 - let mut b = bytes.clone(); - b[32 + 1] = 0x0f; - let corrupted_fill_byte = hex::encode(&b); - assert_ne!(corrupted_fill_byte, good); - assert_eq!(decrypt_to_md5(&corrupted_fill_byte), None); - } -} +pub use sspf_core::cipher::*; diff --git a/src/backend/src/platform/config.rs b/src/backend/src/platform/config.rs index d68244e..5eb9c39 100644 --- a/src/backend/src/platform/config.rs +++ b/src/backend/src/platform/config.rs @@ -1,15 +1,5 @@ -//! config —— 环境变量与路径解析(**转发到 [`sspf_store::config`]**)。 -//! -//! 🔴 真值源在 `crates/sspf-store/src/config.rs`(存储层)。 -//! 本文件只做转发,保持 `crate::platform::config::*` 这个既有路径可用。 -//! -//! 契约:`docs/contract.md` §9「config.rs」。 -//! -//! 路径口径: -//! - `project_dir` = 项目根(由 `main.rs` 从可执行文件向上定位锚点文件得到)。 -//! - `data_dir` = `PGLITE_DIR`,缺省 `/src/backend/data/lite.pg`。 -//! -//! 🔴 `Profile`(部署档位)也定义在 config 里 —— 它是**配置**,不是安全判定; -//! 放 guard 里会造成 `config → guard → db` 的假依赖。 +//! config —— **转发壳**:真源在 [`sspf_core::config`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_store::config::*; +pub use sspf_core::config::*; diff --git a/src/backend/src/platform/crud.rs b/src/backend/src/platform/crud.rs index e1c24d8..41186b1 100644 --- a/src/backend/src/platform/crud.rs +++ b/src/backend/src/platform/crud.rs @@ -1,894 +1,5 @@ -//! crud —— spec 驱动的通用 CRUD 引擎(**平台层**:不含任何业务 spec / 表名 / app_code)。 -//! -//! 🔴 **业务侧([`crate::modules`])把 [`EntitySpec`](crate::platform::entity::EntitySpec) -//! 声明进来,本引擎负责把 spec 变成 SQL**——加一张新业务表**不用改本文件**。 -//! -//! 契约:`docs/contract.md` §5.3(投影列集)+ §6.4(端点)+ §7.6(业务模块语义) -//! 与 §9(`crud.rs` 接口)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/{demo,shop,books}/` -//! 里的 `*.service.ts`(**逐条对齐**)。 -//! -//! 🔴 **七条硬约定**: -//! 1. **业务失败恒 HTTP 200**(信封里的 `code`);DB 报错 ⇒ `系统异常,请联系管理员` -//! (真因只进服务端日志,**不外泄**)。 -//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 -//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `price` 之外的大小写形态 ⇒ 前端读不到, -//! 且**静默**)。 -//! 3. **numeric 列必须投影成字符串**(`f_price::text AS "price"` ⇒ `"9.90"`); -//! `int` 列保持数字(`f_stock` ⇒ `100`)。 -//! 4. **标识符白名单 + 参数化**:表名 / 列名先过 `db::valid_table` / `db::valid_column`; -//! **所有值**走绑定参数,绝不拼进 SQL 文本。 -//! 5. **不用 axum 的 `Json` / `Query`**(前者 422、后者 400 ⇒ 非信封 body ⇒ 契约破) -//! ⇒ 取 `Bytes` / `RawQuery` 自己解析。 -//! 6. **只写 body 里出现的键**(react 的 `Object.assign` / TypeORM 的 `undefined` 语义)。 -//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 -//! -//! 🔴 **Save 的三条路径(顺序不可换,裁决 S20 / S21 / S22)**: -//! | 路径 | 条件 | 写入内容 | -//! |---|---|---| -//! | 1 | body 里**无 id** | 新 uuid + now + `f_delete_mark=0` + spec 的 `default` | -//! | 2 | body 有 id、**库里查不到** | **只用该 id 新建**;body 没给的列**不写** | -//! | 3 | body 有 id、**库里查得到** | 覆盖更新(只覆盖 body 里出现的列) | -//! -//! 🔴 **路径 1 与路径 2 的默认值完全不同**:路径 1 用 spec 的 `default`(`'草稿'` / `'0.00'`), -//! 路径 2 **一个默认值都不加**(`f_stock` / `f_delete_mark` 由 DDL 的 `DEFAULT 0` 补出)。 -//! -//! 🔴 **空 body 的处理是「有意偏离」**:**0 字节 body** ⇒ JSON 解析失败 ⇒ -//! `请求参数格式错误`(HTTP 200 + 信封);而 JSON 数组 / 数字 / 字符串被当作**空对象** ⇒ 走路径 1 建行。 -//! react 侧 express body-parser 对空 body 给 `{}` ⇒ 建行 —— 本仓**有意不跟随**, -//! 依据是契约的通用规则「非法 JSON ⇒ 请求参数格式错误」;契约未覆盖 0 字节 body。 +//! crud —— **转发壳**:真源在 [`sspf_core::crud`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use axum::body::Bytes; -use axum::extract::{RawQuery, State}; -use axum::http::HeaderMap; -use axum::routing::{delete, get, post}; -use axum::{Json, Router}; -use serde_json::{Map, Value}; - -use crate::platform::auth::{require_login, require_login_face_b, require_module}; -use crate::platform::db::{self, pglite, pglite::ToSql, Db}; -use crate::platform::envelope::{code, fail, ok, ActionResult}; -use crate::platform::entity::{ColumnSpec, EntitySpec}; -use crate::platform::ids::new_uuid; -use crate::platform::authorization::has_en_code_permission; -use crate::platform::route::{HttpMethod, PackRoute, RouteAction, RouteGuard}; -use crate::platform::session::TokenUser; -use crate::platform::state::AppState; -use crate::platform::registry; - -/// `f_creator_user_id` 的兜底账号(**账号字符串,不是 uuid**)。 -/// -/// 🔴 `seed.rs` 里也有个同值常量,但那是**私有**的 ⇒ 这里定义自己的(裁决 S18)。 -const ADMIN_ACCOUNT: &str = "admin"; - -// 🔴 **平台层不认 app_code**:哪张表用「`f_creator_user_id` 写死」这条规则,是**业务知识** -// ⇒ 由业务 spec 的 `creator_fixed` 声明(`crate::modules::demo` 声明 `Some("admin")`), -// 引擎只读声明 ⇒ 加新业务表**不用改本文件**(裁决 S22)。 - -// ---------------------------------------------------------------- 通用小工具 - -/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 -fn db_error(e: pglite::Error, ctx: &str) -> Json { - eprintln!("[crud] {ctx}失败: {e}"); - fail(400, "系统异常,请联系管理员") -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} - -/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 -/// -/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 -fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { - values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() -} - -/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 -pub(crate) fn value_to_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => Some(n.to_string()), - Some(Value::Bool(b)) => Some(b.to_string()), - _ => None, - } -} - -/// body 值 ⇒ 文本,但**按 JS 真值判定**(`||` 语义): -/// 空串 / `null` / 数字 `0` / `false` ⇒ `None`(falsy);其余 ⇒ 文本。 -/// -/// 🔴 用于 `body.creatorUserId || 'admin'`(react 的写法)—— 注意它与 -/// `??`([`value_to_text`] + 显式 null 回落)**不是一回事**。 -fn js_truthy_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => { - if n.as_f64().map(|f| f == 0.0).unwrap_or(false) { - None - } else { - Some(n.to_string()) - } - } - Some(Value::Bool(true)) => Some("true".to_string()), - _ => None, - } -} - -/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 -/// -/// 🔴 与 `sys.rs::body_id` **完全一致**(裁决 S20): -/// - 键不存在 / `null` / 空串 ⇒ **无 id**(路径 1); -/// - 非空字符串 ⇒ **有 id**; -/// - 其它类型(数字 / 布尔)⇒ **有 id**(按其 JSON 文本去查)。 -fn body_id(obj: &Map) -> Option { - match obj.get("id") { - None | Some(Value::Null) => None, - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(other) => Some(other.to_string()), - } -} - -/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 -/// -/// 🔴 **不用 axum 的 `Query`**:解析失败会返回 400 + 非信封 body ⇒ 契约破。 -fn query_param(raw: &RawQuery, key: &str) -> String { - let Some(q) = raw.0.as_deref() else { - return String::new(); - }; - let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); - pairs - .into_iter() - .find(|(k, _)| k == key) - .map(|(_, v)| v) - .unwrap_or_default() -} - -/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 -fn parse_body(body: &Bytes) -> Result, Json> { - match serde_json::from_slice::(body) { - Ok(Value::Object(m)) => Ok(m), - // 🔴 **不是对象**(数组 / 数字 / 字符串)⇒ 当作空对象(⇒ 走「参数缺失」分支)。 - Ok(_) => Ok(Map::new()), - Err(_) => Err(fail(400, "请求参数格式错误")), - } -} - -// ---------------------------------------------------------------- spec → SQL - -/// spec 的一列的 JSON 键(**校验它与契约的映射一致**)。 -/// -/// 🔴 `json_key` 写错 ⇒ 投影别名与 body 键**同时**对不上 ⇒ 前端读不到字段,且**静默**。 -fn json_key_of(col: &ColumnSpec) -> Result { - let expect = db::column_to_json_key(col.column); - if expect != col.json_key { - return Err(pglite::Error::Protocol(format!( - "spec 的 json_key 不对: {} 应为 {}(实际 {})", - col.column, expect, col.json_key - ))); - } - Ok(col.json_key.to_string()) -} - -/// 写入口的类型转换后缀(追加在 `::text` 之后)。 -/// -/// 🔴 **规律优于枚举**:任何 `f_*_time` 列都是 `TIMESTAMP`(项目 DDL 约定)⇒ -/// 业务表自带的时间列(如 `f_register_time`)**不用**再往这里加一条 —— -/// 否则「加一个业务模块要改平台层」就被这条类型转换破坏了。 -fn write_cast(column: &str) -> &'static str { - if column.ends_with("_time") { - return "::timestamp"; - } - match column { - "f_price" => "::numeric", - "f_stock" => "::integer", - "f_delete_mark" => "::integer", - _ => "", - } -} - -/// 构造读回投影(`f_xxx AS ""`,**每列都带双引号**)。 -fn projection(spec: &EntitySpec) -> Result { - let mut parts: Vec = Vec::with_capacity(spec.columns.len()); - for col in spec.columns { - let name = db::valid_column(col.column).ok_or_else(|| { - pglite::Error::Protocol(format!("非法列名: {}", col.column)) - })?; - let key = json_key_of(col)?; - parts.push(match col.column { - // 🔴 时间列:NULL 时 `to_char(NULL,…) || 'Z'` ⇒ **NULL**(PG 语义),不是 `"Z"`。 - "f_creator_time" => format!( - "to_char({name}, 'YYYY-MM-DD\"T\"HH24:MI:SS') || 'Z' AS \"{key}\"" - ), - // 🔴 numeric 列必须 `::text` ⇒ JSON 是**字符串**(`"9.90"`)。 - _ if col.numeric => format!("{name}::text AS \"{key}\""), - _ => format!("{name} AS \"{key}\""), - }); - } - Ok(parts.join(", ")) -} - -/// 表名过白名单。 -fn table_of(spec: &EntitySpec) -> Result { - db::valid_table(spec.table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {}", spec.table))) -} - -// ---------------------------------------------------------------- 引擎 - -/// 列出未软删的行(契约 §7.6):`f_delete_mark = 0`,按 `f_creator_time DESC`。 -pub async fn list(db: &Db, spec: &EntitySpec) -> Result, pglite::Error> { - let table = table_of(spec)?; - let proj = projection(spec)?; - let sql = format!( - "SELECT {proj} FROM {table} WHERE f_delete_mark = 0 ORDER BY f_creator_time DESC" - ); - db.query_json(&sql).await -} - -/// 新建 / 更新一行(契约 §7.6 的三条路径)⇒ 返回**落库后重新读回**的那一行。 -pub async fn save(db: &Db, spec: &EntitySpec, body: &Value) -> Result { - let table = table_of(spec)?; - let obj: Map = match body { - Value::Object(m) => m.clone(), - _ => Map::new(), - }; - - let id = match body_id(&obj) { - // ---- 路径 1:无 id ⇒ 新建 ---- - None => { - let new_id = insert_new(db, spec, &table, &obj, None).await?; - new_id - } - // ---- 有 id:查库 ⇒ 路径 2(查不到 ⇒ 用该 id 新建)/ 路径 3(查到 ⇒ 覆盖)---- - Some(given_id) => { - if row_exists(db, &table, &given_id).await? { - update_existing(db, spec, &table, &given_id, &obj).await?; - given_id - } else { - insert_new(db, spec, &table, &obj, Some(given_id)).await? - } - } - }; - - // ---- 响应体 = 落库后重新读回的那一行 ---- - fetch_by_id(db, &table, spec, &id) - .await? - .ok_or_else(|| pglite::Error::Protocol(format!("写入后读不回该行: {id}"))) -} - -/// 软删一行(`f_delete_mark = 1`)—— **不检查是否存在** ⇒ 幂等。 -pub async fn remove(db: &Db, spec: &EntitySpec, id: &str) -> Result<(), pglite::Error> { - let table = table_of(spec)?; - // 🔴 一条 UPDATE ⇒ 天然原子(裁决 S16)。 - let sql = format!("UPDATE {table} SET f_delete_mark = 1 WHERE f_id = $1::text"); - db.exec_params(&sql, &[&id]).await -} - -/// 该 id 的行是否存在(**不过滤 `f_delete_mark`** —— 与 react 的 `findOne({where:{id}})` 一致)。 -async fn row_exists(db: &Db, table: &str, id: &str) -> Result { - let sql = format!("SELECT f_id AS \"id\" FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(!rows.is_empty()) -} - -/// 按 id 读回一行(`None` ⇒ 没有这行)。 -async fn fetch_by_id( - db: &Db, - table: &str, - spec: &EntitySpec, - id: &str, -) -> Result, pglite::Error> { - let proj = projection(spec)?; - let sql = format!("SELECT {proj} FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(rows.into_iter().next()) -} - -/// 插入一行。 -/// -/// - `forced_id = None` ⇒ **路径 1**:新 uuid + now + `f_delete_mark=0` + spec 的 `default`; -/// - `forced_id = Some(id)` ⇒ **路径 2**:用该 id 新建,**body 没给的列一律不写** -/// (⇒ 走 DDL 的 `DEFAULT` / `NULL`;裁决 S21)。 -/// -/// 🔴 **路径 1 与路径 2 的默认值规则完全不同**,别混用。 -async fn insert_new( - db: &Db, - spec: &EntitySpec, - table: &str, - obj: &Map, - forced_id: Option, -) -> Result { - let mut cols: Vec = Vec::with_capacity(spec.columns.len()); - let mut values: Vec> = Vec::with_capacity(spec.columns.len()); - let mut row_id = String::new(); - - for col in spec.columns { - let name = db::valid_column(col.column).ok_or_else(|| { - pglite::Error::Protocol(format!("非法列名: {}", col.column)) - })?; - - // ---- 主键 ---- - if col.column == "f_id" { - row_id = forced_id.clone().unwrap_or_else(new_uuid); - cols.push(name); - values.push(Some(row_id.clone())); - continue; - } - - // ---- 路径 2:body 没给 ⇒ **不写这一列** ---- - // (⇒ `f_creator_time` ⇒ NULL、`f_status`/`f_price` ⇒ NULL、 - // `f_stock`/`f_delete_mark` ⇒ DDL 的 `DEFAULT 0`) - if forced_id.is_some() { - let Some(v) = obj.get(col.json_key) else { - continue; - }; - cols.push(name); - values.push(value_to_text(Some(v))); - continue; - } - - // ---- 路径 1 ---- - let value: Option = match col.column { - "f_creator_time" => Some(now_str()), - // 🔴 路径 1 的 `f_delete_mark` 恒为 0(react 的 `deleteMark: 0` 写死)。 - "f_delete_mark" => Some("0".to_string()), - // 🔴 `f_creator_user_id` 三张表规则不同(裁决 S22): - // demo ⇒ 硬编码 `'admin'`;其余 ⇒ `body.creatorUserId || 'admin'`。 - // 🔴 走哪条由**业务 spec 的 `creator_fixed`** 决定(平台层不认 app_code)。 - "f_creator_user_id" => match spec.creator_fixed { - Some(fixed) => Some(fixed.to_string()), - None => { - // 🔴 JS `||` 语义(空串 / 数字 0 ⇒ 回落 `'admin'`)。 - match js_truthy_text(obj.get(col.json_key)) { - Some(s) => Some(s), - None => Some(ADMIN_ACCOUNT.to_string()), - } - } - }, - // 其余:body 给了就用;没给 ⇒ spec 的 default;再没有 ⇒ NULL。 - // 🔴 JS `??` 语义(react 的 `item.status ?? '草稿'`):**显式 null 也回落默认值**。 - _ => match obj.get(col.json_key) { - Some(Value::Null) | None => col.default.map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }; - cols.push(name); - values.push(value); - } - - if cols.is_empty() { - return Err(pglite::Error::Protocol("没有可写入的列".to_string())); - } - - let placeholders: Vec = (1..=values.len()) - .map(|i| format!("${i}::text{}", write_cast(&cols[i - 1]))) - .collect(); - let sql = format!( - "INSERT INTO {table} ({}) VALUES ({})", - cols.join(", "), - placeholders.join(", ") - ); - db.exec_params(&sql, ¶ms_of(&values)).await?; - Ok(row_id) -} - -/// 覆盖更新一行(路径 3):**只覆盖 body 里出现的该实体已知列**(`Object.assign` 语义)。 -async fn update_existing( - db: &Db, - spec: &EntitySpec, - table: &str, - id: &str, - obj: &Map, -) -> Result<(), pglite::Error> { - let mut assigns: Vec = Vec::new(); - let mut values: Vec> = Vec::new(); - - for col in spec.columns { - // 🔴 主键不参与更新。 - if col.column == "f_id" { - continue; - } - let Some(name) = db::valid_column(col.column) else { - continue; - }; - // 🔴 body 里没有这个键 ⇒ **不动原值**。 - let Some(v) = obj.get(col.json_key) else { - continue; - }; - values.push(value_to_text(Some(v))); - // 🔴 与 `insert_new` 同一写法:值一律按 text 传 ⇒ `$n::text` **必须**带上, - // 否则 PG 会把参数**推断成**目标列类型(`::timestamp` / `::numeric` / `::integer`) - // ⇒ pglite 拿 `Option` 去绑一个 timestamp 参数 ⇒ 直接报 - // `cannot convert between the Rust type ... and the Postgres type timestamp`。 - assigns.push(format!( - "{name} = ${}::text{}", - values.len(), - write_cast(col.column) - )); - } - - // body 里没有任何已知列 ⇒ 什么都不改(react 的 `Object.assign(existing, {})`)。 - if assigns.is_empty() { - return Ok(()); - } - - values.push(Some(id.to_string())); - let sql = format!( - "UPDATE {table} SET {} WHERE f_id = ${}::text", - assigns.join(", "), - values.len() - ); - db.exec_params(&sql, ¶ms_of(&values)).await -} - -// ---------------------------------------------------------------- 守卫 + handler - -/// 按 spec 的 `module_key` 做守卫: -/// - `None` ⇒ **仅登录**; -/// - `Some(k)` ⇒ 登录 + 菜单权限(`require_module` 内含登录判定,**不要**再叠 `require_login`)。 -async fn guard( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, -) -> Result> { - match spec.module_key { - None => require_login(state, headers).await, - Some(key) => require_module(state, headers, key).await, - } -} - -// ---------------------------------------------------------------- 面 B 守卫(业务包路由) -// -// 🔴 **为什么业务包路由要用另一套守卫**(批次 12 交付物 ① 的第 2 条修正): -// 业务包声明的路由是**面 B**(官方 JNPF 形状)⇒ **官方前端会直接调它** -// ⇒ 它的守卫**必须**是面 B 的判据,**不是**面 A 的: -// -// | | 面 A(`/api/ssw/...`) | 面 B(`/api/{模块}/{资源}`) | -// |---|---|---| -// | 判据 | 菜单路径 `f_url_address` | 点权限 `f_en_code` | -// | 官方对应 | `SswPermissionGuard.requireMenu(...)` | `@SaCheckPermission("xxx.yyy")` | -// | 未登录码 | **600** | **602**(官方前端只在 601/602 清 token) | -// -// 🔴 **602 这条是硬要求**(`MIGRATION.md` §2.5):官方前端 -// `request.ts:78-80` 只对 `601`/`602` 清 token ⇒ 只返 600 会让页面**卡住不跳登录**。 -// ⇒ 面 A 保持 600、面 B 返 602 —— **两套并存**(与判据一样并存)。 - -/// 面 B 的守卫:**登录(602)** + **点权限(`f_en_code` ⇒ 403)**。 -/// -/// 🔴 与 [`face_b`] 模块里的同名函数**同义**(逐字同构)—— 官方 -/// `@SaCheckPermission("xxx")` 的判据就是 `base_module.f_en_code`。 -async fn guard_face_b( - state: &AppState, - headers: &HeaderMap, - en_code: &str, -) -> Result> { - let user = require_login_face_b(state, headers).await?; - let system_id = - registry::resolve_system_id(&state.db, registry::app_code_of(headers).as_deref()).await; - if has_en_code_permission(&state.db, &user.user_id, user.is_admin, en_code, &system_id).await { - Ok(user) - } else { - Err(fail(code::NO_PERMISSION, "无权限")) - } -} - -/// 业务包路由的守卫(按声明的 [`RouteGuard`] 分派)。 -async fn guard_pack( - state: &AppState, - headers: &HeaderMap, - guard: RouteGuard, -) -> Result> { - match guard { - RouteGuard::Login => require_login_face_b(state, headers).await, - RouteGuard::EnCode(en_code) => guard_face_b(state, headers, en_code).await, - } -} - -/// List 的通用实现。 -pub(crate) async fn handle_list( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - match list(&state.db, spec).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "业务列表查询"), - } -} - -/// Save 的通用实现。 -pub(crate) async fn handle_save( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - body: &Bytes, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - let obj = match parse_body(body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let value = Value::Object(obj); - match save(&state.db, spec, &value).await { - Ok(row) => ok(row), - Err(e) => db_error(e, "业务保存"), - } -} - -/// Delete 的通用实现(**不检查是否存在** ⇒ 幂等)。 -pub(crate) async fn handle_delete( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - raw: &RawQuery, -) -> Json { - if let Err(resp) = guard(state, headers, spec).await { - return resp; - } - let id = query_param(raw, "id"); - match remove(&state.db, spec, &id).await { - Ok(()) => ok(Value::Null), - Err(e) => db_error(e, "业务删除"), - } -} - -// ---------------------------------------------------------------- 面 B 的业务包 handler -// -// 🔴 **为什么业务包路由的响应形状与面 A 不同**: -// 官方 `ActionResult.page(list, pagination)` ⇒ `data` 是 **`PageListVO`** -// (`{pagination:{currentPage,pageSize,total}, list:[…]}`), -// **不是**裸数组(面 A 才是裸数组)。 -// ⇒ 官方前端拿到裸数组 ⇒ 读 `res.data.list` 是 `undefined` ⇒ **静默**空表格。 -// ⇒ 这就是「官方前端能直连本仓」的那条承诺里最容易被忽略的一格。 -// -// 🔴 **分页参数**:官方 `Pagination.java` 默认 `currentPage=1` / `pageSize=20`, -// 夹逼 `[1, 1000]`(与 [`face_b::Paging`] 同口径)。 - -/// 取分页参数(官方 `Pagination` 默认值 + 夹逼)。 -struct PackPaging { - current_page: i64, - page_size: i64, - offset: i64, -} - -impl PackPaging { - fn of(raw: &RawQuery) -> Self { - let current_page = crate::platform::sys::query_param(raw, "currentPage") - .trim() - .parse::() - .unwrap_or(1) - .max(1); - let page_size = crate::platform::sys::query_param(raw, "pageSize") - .trim() - .parse::() - .unwrap_or(20) - .clamp(1, 1000); - Self { - current_page, - page_size, - offset: (current_page - 1) * page_size, - } - } -} - -/// 官方 `PageListVO` —— `{pagination:{currentPage,pageSize,total}, list:[…]}`。 -fn pack_page_list(current_page: i64, page_size: i64, total: i64, list: Vec) -> Value { - serde_json::json!({ - "pagination": { - "currentPage": current_page, - "pageSize": page_size, - "total": total, - }, - "list": list, - }) -} - -/// 面 B 的列表(分页 + `PageListVO` 形状)。 -pub(crate) async fn handle_list_face_b( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - guard: RouteGuard, - raw: &RawQuery, -) -> Json { - if let Err(resp) = guard_pack(state, headers, guard).await { - return resp; - } - let page = PackPaging::of(raw); - let table = match db::valid_table(spec.table) { - Some(t) => t, - None => return fail(400, "系统异常,请联系管理员"), - }; - let proj = match projection(spec) { - Ok(p) => p, - Err(_) => return fail(400, "系统异常,请联系管理员"), - }; - // 🔴 **总数与列表两条 SQL**(官方 `IPage` 的等价做法)。 - let total_sql = format!("SELECT count(*)::bigint AS \"c\" FROM {table} WHERE f_delete_mark = 0"); - let total = match state.db.query_json(&total_sql).await { - Ok(rows) => rows - .into_iter() - .next() - .and_then(|r| r["c"].as_i64()) - .unwrap_or(0), - Err(e) => return db_error(e, "业务列表计数"), - }; - let list_sql = format!( - "SELECT {proj} FROM {table} WHERE f_delete_mark = 0 \ - ORDER BY f_creator_time DESC LIMIT {page_size} OFFSET {page_offset}", - page_size = page.page_size, - page_offset = page.offset, - ); - let rows = match state.db.query_json(&list_sql).await { - Ok(rows) => rows, - Err(e) => return db_error(e, "业务列表查询"), - }; - ok(pack_page_list( - page.current_page, - page.page_size, - total, - rows, - )) -} - -/// 面 B 的新建 / 更新(响应 = 落库后读回的那一行,与面 A 同形)。 -pub(crate) async fn handle_save_face_b( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - guard: RouteGuard, - body: &Bytes, -) -> Json { - if let Err(resp) = guard_pack(state, headers, guard).await { - return resp; - } - let obj = match parse_body(body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let value = Value::Object(obj); - match save(&state.db, spec, &value).await { - Ok(row) => ok(row), - Err(e) => db_error(e, "业务保存"), - } -} - -/// 面 B 的软删(`{id}` 走路径参数)。 -pub(crate) async fn handle_delete_face_b( - state: &AppState, - headers: &HeaderMap, - spec: &EntitySpec, - guard: RouteGuard, - id: &str, -) -> Json { - if let Err(resp) = guard_pack(state, headers, guard).await { - return resp; - } - match remove(&state.db, spec, id).await { - Ok(()) => ok(Value::Null), - Err(e) => db_error(e, "业务删除"), - } -} - -// ---------------------------------------------------------------- spec 取值(编译期常量) -// -// 🔴 **平台层不持有任何业务 spec** —— spec 全在 [`crate::modules`](demo / shop / books)。 -// 引擎只认传入的 `&EntitySpec` ⇒ 加一张新业务表**不用改本文件**。 - -// ---------------------------------------------------------------- 路由生成(spec 驱动) -// -// 🔴 **这是「业务包自带路由、平台层零改动」的落点**(批次 12 交付物 ①): -// 业务包声明 [`PackRoute`](纯数据:路径 + 方法 + 实体名), -// 本函数按声明**生成真正的 axum 路由** —— 引擎认识 spec ⇒ 直接复用。 -// ⇒ 业务包**不需要**依赖 axum(AR2/AR8 钉死),内核**不需要**知道任何业务路径。 - -/// 按业务包声明的路由生成 axum 路由(`Router::merge` 进总路由)。 -/// -/// 🔴 **入参是 `&[&'static PackRoute]`** —— 路由声明是编译期常量, -/// 这里只读不写。 -/// -/// 🔴 **动作与方法的对应关系被钉死**(不许自由组合): -/// | action | 允许的 method | 语义 | id 来源 | -/// |---|---|---|---| -/// | `List` | GET | 查列表(分页 + `PageListVO`) | — | -/// | `Save` | POST | 新建 / 更新 | body 的 `id` | -/// | `Delete` | DELETE | 软删 | **路径参数 `{id}`** | -/// -/// 🔴 **Delete 的 id 走路径参数**(官方 RESTful:`DELETE /api/{模块}/{资源}/{id}`) -/// ⇒ 路径里**必须**含 `{id}` ⇒ 不含就不生成这条路由(宁可少一条,也不要一条 -/// 永远收不到 id 的路由 —— 那种路由会静默删掉空 id 的行)。 -/// -/// 不在表里的组合 ⇒ **不生成路由**(而不是生成一个恒 400 的空实现)。 -/// 理由:官方 JNPF 有一批非 CRUD 端点(`/AsyncList/{id}` / `/Actions/ResetPassword`), -/// 它们由面 B 的专用 handler 实现,**不归业务包管**。 -/// -/// 🔴 **返回值类型是 `Router`** —— 与 `modules::router()` 一致, -/// 内核只需 `.merge(...)` 一次。 -pub fn crud_router(spec: &'static EntitySpec, routes: &[&'static PackRoute]) -> Router { - let mut router = Router::new(); - for r in routes { - // 🔴 路由的 entity 必须与 spec 对得上(装载器已校验过,这里是二道闸)。 - if r.entity != spec.entity { - continue; - } - // 🔴 **先把要捕获的值拷出来**(`Copy` 类型)—— - // 直接在闭包里写 `r.guard` 会把 `r`(指向入参切片,生命周期 `'1`) - // 一起捕获 ⇒ 编译报「borrowed data escapes outside of function」。 - let path = r.path; - let guard = r.guard; - match (r.action, r.method) { - (RouteAction::List, HttpMethod::Get) => { - router = router.route( - path, - get( - move |State(state): State, - headers: HeaderMap, - raw: RawQuery| async move { - handle_list_face_b(&state, &headers, spec, guard, &raw).await - }, - ), - ); - } - (RouteAction::Save, HttpMethod::Post) => { - router = router.route( - path, - post( - move |State(state): State, - headers: HeaderMap, - body: Bytes| async move { - handle_save_face_b(&state, &headers, spec, guard, &body).await - }, - ), - ); - } - (RouteAction::Delete, HttpMethod::Delete) => { - // 🔴 路径必须带 `{id}` —— 官方 RESTful 的删除是 `DELETE /api/{模块}/{资源}/{id}`。 - if !path.contains("{id}") { - continue; - } - router = router.route( - path, - delete( - move |State(state): State, - headers: HeaderMap, - axum::extract::Path(id): axum::extract::Path| async move { - handle_delete_face_b(&state, &headers, spec, guard, &id).await - }, - ), - ); - } - // 🔴 不在表里的组合 ⇒ **不生成路由**(静默跳过 = 少一条路由 = 404, - // 而不是 400 ⇒ 前端能区分「端点不存在」与「业务拒绝」)。 - _ => {} - } - } - router -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 投影里**每一列都带双引号别名**,且 numeric 列 `::text`、时间列 `to_char`。 - #[test] - fn projection_uses_quoted_aliases() { - let product = &crate::modules::shop::PRODUCT_SPEC; - let proj = projection(product).expect("投影构造"); - assert!(proj.contains(r#"f_id AS "id""#), "投影: {proj}"); - assert!(proj.contains(r#"f_price::text AS "price""#), "投影: {proj}"); - assert!( - proj.contains(r#"to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime""#), - "投影: {proj}" - ); - // 🔴 不得出现 `SELECT *`。 - assert!(!proj.contains('*'), "投影: {proj}"); - } - - /// 三张表的投影列数 = spec 列数。 - #[test] - fn projection_covers_every_spec_column() { - for spec in crate::modules::all_specs() { - let proj = projection(spec).expect("投影构造"); - let count = proj.split(" AS ").count() - 1; - assert_eq!(count, spec.columns.len(), "{} 的投影列数不对", spec.table); - } - } - - /// `body_id` 的判定与 `sys.rs::body_id` 一致(裁决 S20)。 - #[test] - fn body_id_semantics() { - let mut obj = Map::new(); - assert_eq!(body_id(&obj), None, "键不存在 ⇒ 无 id"); - obj.insert("id".to_string(), Value::Null); - assert_eq!(body_id(&obj), None, "null ⇒ 无 id"); - obj.insert("id".to_string(), Value::String(String::new())); - assert_eq!(body_id(&obj), None, "空串 ⇒ 无 id"); - obj.insert("id".to_string(), Value::String("abc".to_string())); - assert_eq!(body_id(&obj), Some("abc".to_string())); - obj.insert("id".to_string(), Value::Number(123.into())); - assert_eq!(body_id(&obj), Some("123".to_string()), "数字也算有 id"); - } - - /// 写入口的类型转换:`f_price` ⇒ numeric、`f_stock` ⇒ integer、`*_time` ⇒ timestamp。 - #[test] - fn write_casts() { - assert_eq!(write_cast("f_price"), "::numeric"); - assert_eq!(write_cast("f_stock"), "::integer"); - assert_eq!(write_cast("f_delete_mark"), "::integer"); - assert_eq!(write_cast("f_creator_time"), "::timestamp"); - // 🔴 `_time` 后缀是**通用规则**(不是逐列枚举)⇒ 业务表自带的时间列自动带上转换。 - assert_eq!(write_cast("f_register_time"), "::timestamp"); - assert_eq!(write_cast("f_title"), ""); - } - - /// body 值 ⇒ 文本:字符串原样、数字 / 布尔转文本、null / 对象 / 数组 ⇒ None。 - #[test] - fn value_to_text_rules() { - assert_eq!( - value_to_text(Some(&Value::String("x".to_string()))), - Some("x".to_string()) - ); - assert_eq!( - value_to_text(Some(&Value::Number(100.into()))), - Some("100".to_string()) - ); - assert_eq!( - value_to_text(Some(&Value::Bool(true))), - Some("true".to_string()) - ); - assert_eq!(value_to_text(Some(&Value::Null)), None); - assert_eq!(value_to_text(Some(&Value::Array(vec![]))), None); - assert_eq!(value_to_text(None), None); - } - - /// spec 的 json_key 与契约映射不一致 ⇒ 报错(而不是静默产出错键名)。 - #[test] - fn json_key_mismatch_is_rejected() { - let bad = ColumnSpec { - column: "f_title", - json_key: "Title", - default: None, - numeric: false, - }; - assert!(json_key_of(&bad).is_err()); - } - - /// 🔴 **numeric 列必须落在 `write_cast` 的 `::numeric` 映射里**。 - /// - /// 少了这层转换 ⇒ PG 报 `column is of type numeric but expression is of type text` - /// ⇒ 只在**运行时**变成「系统异常」信封,编译期 / 启动期无任何提示。 - #[test] - fn every_numeric_spec_column_has_a_numeric_write_cast() { - let mut numeric_cols = 0usize; - for spec in crate::modules::all_specs() { - for col in spec.columns { - if col.numeric { - numeric_cols += 1; - assert_eq!( - write_cast(col.column), - "::numeric", - "{} 的 {} 是 numeric 列,写入必须带 ::numeric", - spec.table, - col.column - ); - } - } - } - assert!(numeric_cols > 0, "必须至少有一个 numeric 列(否则本测试空转)"); - // 其余硬编码的类型转换也一并钉住。 - assert_eq!(write_cast("f_stock"), "::integer"); - assert_eq!(write_cast("f_delete_mark"), "::integer"); - assert_eq!(write_cast("f_creator_time"), "::timestamp"); - } -} +pub use sspf_core::crud::*; diff --git a/src/backend/src/platform/db.rs b/src/backend/src/platform/db.rs index ddaa945..342862b 100644 --- a/src/backend/src/platform/db.rs +++ b/src/backend/src/platform/db.rs @@ -1,13 +1,5 @@ -//! db —— 数据库访问(**转发到 [`sspf_store::db`]**)。 -//! -//! 🔴 真值源在 `crates/sspf-store/src/db.rs`(存储层,**不认识 HTTP**)。 -//! 本文件只做转发,保持 `crate::platform::db::*` 这个既有路径可用 ⇒ -//! 拆分 crate 对上层零感知(业务层、集成测试、引文行号都不用动)。 -//! -//! 契约:`docs/contract.md` §5.4 / §5.5。 -//! DDL 唯一真源:`src/backend/db/schema.sql`(**不在 web root**,杜绝 DDL 可被 HTTP 下载)。 -//! -//! 🔴 为什么独立成 crate:存储层要给低代码引擎、后台任务、CLI、MCP 适配器共用, -//! 不能因为「内核用 axum」就让所有消费者都拖一个 web 框架(见 `PLAN.md` §3.2 AR6)。 +//! db —— **转发壳**:真源在 [`sspf_core::db`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_store::db::*; +pub use sspf_core::db::*; diff --git a/src/backend/src/platform/entity.rs b/src/backend/src/platform/entity.rs index 66872ab..86ec5a0 100644 --- a/src/backend/src/platform/entity.rs +++ b/src/backend/src/platform/entity.rs @@ -1,11 +1,5 @@ -//! entity —— **业务实体 spec 的类型定义**(转发到契约层)。 -//! -//! 🔴 真值源在 [`sspf_contract::entity`](契约层)。 -//! 本文件只做转发,原因是 `crate::platform::entity::*` 是既有路径, -//! 业务层与测试都这么引用;保持路径稳定 ⇒ 拆分 crate 对上层零感知。 -//! -//! 🔴 **本文件只放「类型」,不放任何业务 spec** —— 业务 spec 住在 `packs//`。 -//! -//! 契约:`docs/contract.md` §5.3(精确列清单 = 投影真源)+ §6.4(端点)+ §9(接口)。 +//! entity —— **转发壳**:真源在 [`sspf_core::entity`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_contract::entity::{ColumnSpec, EntitySpec}; +pub use sspf_core::entity::*; diff --git a/src/backend/src/platform/envelope.rs b/src/backend/src/platform/envelope.rs index 645fcbc..6e99960 100644 --- a/src/backend/src/platform/envelope.rs +++ b/src/backend/src/platform/envelope.rs @@ -1,79 +1,5 @@ -//! envelope —— `ActionResult{code,msg,data}` 统一信封(**HTTP 包装层**)。 -//! -//! 🔴 **类型与码表在 [`sspf_contract::envelope`]**(契约层,不依赖 axum)。 -//! 本文件只负责把它包成 `axum::Json`,以及钉住「业务失败恒 HTTP 200」这一条。 -//! -//! 契约(**不得改动**,见 `docs/contract.md` §2 与 §1.2): -//! ```json -//! { "code": 200, "msg": "成功", "data": null } -//! ``` -//! -//! - 业务失败(`400` / `600` / `403`)**恒 HTTP 200**,成败只看 body 的 `code`。 -//! - 唯一**传输层**例外:未知路由 404、方法不对 405 —— 但 body 仍是本信封形状。 -//! - `data` 原样透传,失败时恒为 `null`。 +//! envelope —— **转发壳**:真源在 [`sspf_core::envelope`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use axum::Json; -use serde_json::Value; - -pub use sspf_contract::envelope::{code, ActionResult}; - -/// 成功信封:`code=200`、`msg="成功"`、`data` **原样透传**。 -pub fn ok(data: Value) -> Json { - Json(ActionResult::ok(data)) -} - -/// 失败信封:`code=`、`msg=`、`data=null`。 -/// -/// 🔴 **恒 HTTP 200** —— 业务失败不是传输层错误,别在这里改状态码。 -pub fn fail(code: i32, msg: impl Into) -> Json { - Json(ActionResult::fail(code, msg)) -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 🔴 业务失败**恒 HTTP 200** —— 把 `fail()` 挂到真实 router 上,用裸 TCP 发一次请求验证状态码。 - /// (`docs/contract.md` §1.2 / §12 的验收点:业务失败是 HTTP 200,不是 4xx。) - #[tokio::test] - async fn fail_responds_with_http_200_and_envelope_body() { - use tokio::io::{AsyncReadExt, AsyncWriteExt}; - - let app = axum::Router::new().route( - "/boom", - axum::routing::get(|| async { fail(400, "账号已存在:smoke_user") }), - ); - - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap(); - let addr = listener.local_addr().unwrap(); - let server = tokio::spawn(async move { - axum::serve(listener, app).await.unwrap(); - }); - - let mut stream = tokio::net::TcpStream::connect(addr).await.unwrap(); - // 🔴 收发都套超时:没有超时的话,服务端不响应时这个测试会**永久挂住**而不是失败。 - let mut raw = Vec::new(); - tokio::time::timeout(std::time::Duration::from_secs(5), async { - stream - .write_all(b"GET /boom HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n") - .await - .unwrap(); - stream.read_to_end(&mut raw).await.unwrap(); - }) - .await - .expect("HTTP 往返超时(5s)——业务失败必须立刻返回 HTTP 200,不该挂住"); - server.abort(); - - let raw = String::from_utf8_lossy(&raw).to_string(); - let (head, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔"); - assert!( - head.starts_with("HTTP/1.1 200 OK"), - "业务失败必须是 HTTP 200,实际响应头: {head}" - ); - - let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON"); - assert_eq!(body["code"], 400); - assert_eq!(body["msg"], "账号已存在:smoke_user"); - assert_eq!(body["data"], Value::Null); - } -} +pub use sspf_core::envelope::*; diff --git a/src/backend/src/platform/guard.rs b/src/backend/src/platform/guard.rs index f653216..a7f9bbf 100644 --- a/src/backend/src/platform/guard.rs +++ b/src/backend/src/platform/guard.rs @@ -1,329 +1,5 @@ -//! guard —— **生产档弱密钥守卫**(平台层,纯函数 + 一次库回读)。 -//! -//! 🔴 **本仓自定判据**,**不是**照抄兄弟项目 `tdc-rs` 的 `ProdGuard` —— -//! 那个守卫是 `tdc-rs` 的 **Java 上游真源**(`ssw.common.guard.ProdGuard`)的移植, -//! 本仓**没有**对应的上游(本仓的上游是 react 版 + 官方 JNPF Java,两者都不含这个守卫), -//! ⇒ 照抄过来只会得到「六条判据看着严,其实管的是别人的弱值面」。 -//! -//! **本仓的弱值面只有两处**: -//! 1. `SEED_ADMIN_PASSWORD`(env)—— 缺省 `123456`(契约 §8.6 的 admin 种子口令)。 -//! 🔴 这是本仓**唯一**的「拿到就能登录」的口令 ⇒ 生产档必须换掉。 -//! 2. `CIPHER_KEY` —— **协议共享值**(前端要用它加密口令)⇒ **故意不受管**(见下)。 -//! -//! 🔴 **协议共享值不受管**:`cipher.rs` 的 `CIPHER_KEY` 必须是 `md5_hex` 的**输入**, -//! 官方前端的 `cipher.ts` 用的是**同一个**常量 ⇒ 改它 ⇒ 前端加密出来的密文解不开 -//! ⇒ **整个登录链路当场报废**。它不是「忘了改的弱密钥」,它是**契约的一部分** -//! ⇒ 判据①(键不在本部署的清单里 ⇒ 跳过)在这里生效:本守卫的清单里**没有**它。 -//! -//! ## 档位 -//! -//! `SSW_PROFILE` env:`dev`(**缺省**)/ `prod`。 -//! - `dev`(缺省):**一律不判**(本仓的默认形态就是「本地开发/演示」), -//! ⇒ 契约与冒烟脚本**零影响**(种子口令恒 `123456`)。 -//! - `prod`:**下面六条判据逐条生效**,任一违规 ⇒ **拒绝启动**(人话报错 + `exit 1`)。 -//! -//! ## 六条判据(弱值判定,通用口径) -//! -//! ① **键不在本部署的清单里** ⇒ **跳过**(不判本部署根本没有的键)。 -//! ② 值为 `null` / 空白 ⇒ 违规。 -//! ③ 值**精确等于**已知弱值 ⇒ 违规。 -//! ④ 值**含**已知弱值 ⇒ 违规(**反绕过**:只比精确值时,`123456x` 能溜过去)。 -//! ⑤ 值命中**弱标记词**(**整体词**匹配,不是子串)⇒ 违规。 -//! ⑥ 长度 < [`MIN_LEN`] ⇒ 违规。 -//! -//! —— 并且:**强值必放行**(防「守卫恒红」:一条判据写错就再也起不来了)。 +//! guard —— **转发壳**:真源在 [`sspf_core::guard`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use crate::platform::db::Db; - -/// 生产档口令的**最小长度**(判据⑥)。 -pub const MIN_LEN: usize = 12; - -/// 部署档位(**定义在 [`crate::platform::config`]**,这里转发保持既有路径可用)。 -/// -/// 🔴 档位是「配置」不是「安全判定」:它从 env 读、决定判据要不要生效。 -/// 定义在 guard 里会造成 `config → guard → db` 的**假依赖** —— -/// 拆 crate 时会变成真循环依赖,必须提前断开。 -pub use crate::platform::config::Profile; - -/// 已知弱值 —— **精确相等**即违规(判据③)。 -/// -/// 🔴 只收**本仓真会出现的**弱值:`123456` 是本仓的 admin 种子口令(契约 §8.6), -/// 其余是通用弱口令 ⇒ 换一份实现时**不必**改这里。 -pub const WEAK_EXACT: &[&str] = &[ - "123456", "admin", "admin123", "password", "changeme", "12345678", "111111", "000000", -]; - -/// 已知弱值 —— **包含**即违规(判据④,反绕过)。 -/// -/// 🔴 **只收「不作为更长单词子串出现」的 token**:`admin` 不在里面 -/// (`administrator` 含 `admin` ⇒ 会误伤);`password` 在里面 -/// (`password123` 必是弱值)。 -pub const WEAK_CONTAINS: &[&str] = &["123456", "changeme", "password", "qwerty", "letmein"]; - -/// 弱标记词 —— **整体词**命中即违规(判据⑤)。 -/// -/// 匹配口径:把值按**非字母数字**切成词,逐词**全等**比较 ⇒ -/// `demo-2024` 命中 `demo`;`demonstration` **不**命中(那是一个整词 `demonstration`)。 -pub const WEAK_MARKER_WORDS: &[&str] = &[ - "demo", "test", "example", "sample", "default", "admin", "guest", "user", "temp", -]; - -/// 一条违规(**点名**是哪个键、哪条判据 ⇒ 报错能直接指向要改什么)。 -#[derive(Clone, Debug, PartialEq, Eq)] -pub struct Violation { - /// 违规的键名。 - pub key: String, - /// 违规原因(人话,含判据编号)。 - pub reason: String, -} - -impl std::fmt::Display for Violation { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "{}:{}", self.key, self.reason) - } -} - -/// 把值按**非字母数字**切成词(判据⑤的分词口径)。 -fn words_of(value: &str) -> Vec { - value - .split(|c: char| !c.is_alphanumeric()) - .filter(|w| !w.is_empty()) - .map(|w| w.to_ascii_lowercase()) - .collect() -} - -/// 判定**单个**值是否弱(返回全部违规原因;空 vec = 通过)。 -/// -/// 🔴 **纯函数**(不读 env、不读库、不看全局状态)⇒ 可单测、可在别处复用。 -/// -/// 🔴 判据③ 只比**精确相等**(大小写不敏感);判据④ 比**包含**(大小写不敏感)。 -pub fn weak_reasons(value: &str) -> Vec { - let mut reasons = Vec::new(); - let trimmed = value.trim(); - - // ② 空 / 空白 - if trimmed.is_empty() { - reasons.push("判据②:值为空/空白".to_string()); - // 空值也必然过不了 ⑥,但只报一次 ⇒ 直接返回。 - return reasons; - } - - let lower = trimmed.to_ascii_lowercase(); - - // ③ 精确等于已知弱值 - if WEAK_EXACT.iter().any(|w| lower == w.to_ascii_lowercase()) { - reasons.push(format!("判据③:值等于已知弱值({trimmed})")); - } - - // ④ 包含已知弱值(反绕过) - if let Some(hit) = WEAK_CONTAINS - .iter() - .find(|w| lower.contains(&w.to_ascii_lowercase())) - { - reasons.push(format!("判据④:值包含已知弱值({hit})")); - } - - // ⑤ 命中弱标记词(整体词) - let words = words_of(trimmed); - if let Some(hit) = WEAK_MARKER_WORDS - .iter() - .find(|w| words.iter().any(|word| word == &w.to_ascii_lowercase())) - { - reasons.push(format!("判据⑤:值命中弱标记词({hit})")); - } - - // ⑥ 长度下限 - if trimmed.chars().count() < MIN_LEN { - reasons.push(format!( - "判据⑥:长度 {} < {MIN_LEN}", - trimmed.chars().count() - )); - } - - reasons -} - -/// 判定**单个**值是否弱(只看是否违规,不看原因)。 -pub fn is_weak(value: &str) -> bool { - !weak_reasons(value).is_empty() -} - -/// 生产档的**配置级**守卫:逐个键判,返回全部违规。 -/// -/// 🔴 **键不在清单里 ⇒ 不判**(判据①):调用方只把「本部署真有的键」放进来。 -/// -/// - `values` = 本部署真实存在的键值对(如 `[(键名, 值)]`)。 -pub fn check_values(values: &[(String, String)]) -> Vec { - let mut out = Vec::new(); - for (key, value) in values { - for reason in weak_reasons(value) { - out.push(Violation { - key: key.clone(), - reason, - }); - } - } - out -} - -/// 把违规渲染成人话(**点名键 + 原因**),供启动失败时打印。 -pub fn render_violations(violations: &[Violation]) -> String { - let mut s = String::new(); - for (i, v) in violations.iter().enumerate() { - if i > 0 { - s.push('\n'); - } - s.push_str(" - "); - s.push_str(&v.to_string()); - } - s -} - -/// 🔴 **库内**校验:admin 账号当前的口令**是不是已知弱值**(生产档)。 -/// -/// 🔴 **为什么必须回读库里那行**:种子口令只对**空库**生效(`first_seed` 仅当 -/// `base_user` 行为 0 时跑)⇒ 生产库里 admin 的口令可能是**当初**种下的 -/// `123456`,而运维**后来**才设了 `SEED_ADMIN_PASSWORD` ⇒ -/// **配置看着是强的、库里其实是弱的** ⇒ 只查配置 = 守卫形同虚设。 -/// -/// 🔴 **为什么只比「已知弱值」而不是比「配置里那个」**:管理员**合法**在界面上 -/// 改过口令后,库里那个自然不等于配置里那个 ⇒ 若拿配置去比, -/// **每次改完口令都得改配置**,否则服务起不来 ⇒ 那是误伤。 -/// 本守卫只回答「这个口令是不是**人人皆知的弱口令**」⇒ 改过口令 ⇒ 放行; -/// 还是默认的 `123456` ⇒ 拦。 -/// -/// - `db`:库句柄。 -/// -/// 返回 `Ok(())` = 通过;`Err(msg)` = 人话错误。 -pub async fn verify_stored_admin_password(db: &Db) -> Result<(), String> { - let rows = db - .query_json( - "SELECT f_id AS \"id\", f_account AS \"account\", f_password AS \"password\" \ - FROM base_user WHERE f_is_administrator = 1 ORDER BY f_id LIMIT 1", - ) - .await - .map_err(|e| format!("读取 admin 行失败: {e}"))?; - - let Some(row) = rows.first() else { - // 没有 admin 行 ⇒ 不是「弱口令」,是「没建账号」⇒ 不归本守卫管。 - return Ok(()); - }; - - let stored = row["password"].as_str().unwrap_or_default(); - if stored.is_empty() { - return Err("admin 行的 f_password 为空 ⇒ 无法校验(请在管理界面重置口令)".to_string()); - } - - // 库里存的是 md5(明文) ⇒ 拿每个弱值的 md5 去比。 - for weak in WEAK_EXACT { - if stored.eq_ignore_ascii_case(&crate::platform::cipher::md5_hex(weak)) { - return Err(format!( - "admin 账号的库内口令仍是**已知弱口令**({weak})—— \ - 种子口令只对空库生效,库里是当初种下的那个。\ - 请在管理界面重置 admin 口令,或清库重来。" - )); - } - } - Ok(()) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn reasons(v: &str) -> Vec { - weak_reasons(v) - } - - /// ⑥ 长度下限:短的 ⇒ 违规,长的 ⇒ 不因长度违规。 - #[test] - fn min_len_is_enforced() { - assert!(reasons("short1A!").iter().any(|r| r.contains("判据⑥"))); - assert!(!reasons("Xk9mQ2vL7pR4zW8").iter().any(|r| r.contains("判据⑥"))); - } - - /// ③ 精确弱值 ⇒ 违规。 - #[test] - fn exact_weak_value_is_blocked() { - assert!(reasons("123456").iter().any(|r| r.contains("判据③"))); - assert!(reasons("admin").iter().any(|r| r.contains("判据③"))); - } - - /// ④ **反绕过**:默认口令加个后缀 ⇒ 仍然违规。 - #[test] - fn weak_value_with_suffix_is_blocked() { - assert!(reasons("123456x").iter().any(|r| r.contains("判据④"))); - } - - /// ④ 不得误伤 `administrator`(`admin` 只在**精确**与**整体词**两条里)。 - #[test] - fn administrator_is_not_a_false_positive() { - let rs = reasons("administrator9Q!x"); - assert!( - !rs.iter().any(|r| r.contains("判据④")), - "administrator 不该命中判据④:{rs:?}" - ); - } - - /// ⑤ 弱标记词:**整体词**命中,不是子串。 - /// - /// 🔴 分词口径 = 按**非字母数字**切 ⇒ `demo-2024` 是两个词(`demo` 命中), - /// 而 `demo2024` 是**一个词**(`demo` 不命中)——这是「整体词」的设计后果, - /// 避免 `administrator` / `demonstration` 这类正常词被误伤。 - #[test] - fn marker_word_is_whole_word_only() { - assert!(reasons("demo-2024Q!x").iter().any(|r| r.contains("判据⑤"))); - assert!(!reasons("demonstration9Q!x") - .iter() - .any(|r| r.contains("判据⑤"))); - } - - /// 🔴 `demo2024` 这类**连写**的弱口令:⑤ 不命中(整体词),但 **⑥ 长度**兜住。 - /// - /// ⇒ 钉住「六条判据是**并集**,不是各自独立」:任一条命中即违规。 - #[test] - fn joined_marker_is_caught_by_the_length_rule() { - let rs = reasons("demo2024Q!x"); - assert!( - !rs.iter().any(|r| r.contains("判据⑤")), - "连写的 demo2024 不该命中整体词判据:{rs:?}" - ); - assert!( - rs.iter().any(|r| r.contains("判据⑥")), - "但它必须被长度判据兜住:{rs:?}" - ); - } - - /// ② 空值 ⇒ 违规。 - #[test] - fn blank_value_is_named() { - assert!(reasons(" ").iter().any(|r| r.contains("判据②"))); - } - - /// 🔴 **强值必放行**(防「守卫恒红」)。 - #[test] - fn strong_value_is_allowed() { - assert!(reasons("Xk9mQ2vL7pR4zW8").is_empty()); - assert!(!is_weak("Xk9mQ2vL7pR4zW8")); - } - - /// 档位解析:非法值回落 `Dev`(不误伤本地开发)。 - #[test] - fn profile_parses_leniently() { - assert_eq!(Profile::from_env_str("prod"), Profile::Prod); - assert_eq!(Profile::from_env_str("PRODUCTION"), Profile::Prod); - assert_eq!(Profile::from_env_str("prod "), Profile::Prod); - assert_eq!(Profile::from_env_str("dev"), Profile::Dev); - assert_eq!(Profile::from_env_str(""), Profile::Dev); - assert_eq!(Profile::from_env_str("productionn"), Profile::Dev); - } - - /// 守卫报错**点名键**(运维要能直接照着改)。 - #[test] - fn violation_message_names_the_key() { - let vs = check_values(&[("SEED_ADMIN_PASSWORD".to_string(), "123456".to_string())]); - assert!(!vs.is_empty()); - assert_eq!(vs[0].key, "SEED_ADMIN_PASSWORD"); - assert!(render_violations(&vs).contains("SEED_ADMIN_PASSWORD")); - } -} +pub use sspf_core::guard::*; diff --git a/src/backend/src/platform/ids.rs b/src/backend/src/platform/ids.rs index 46b96a5..c79eb2a 100644 --- a/src/backend/src/platform/ids.rs +++ b/src/backend/src/platform/ids.rs @@ -1,8 +1,5 @@ -//! ids —— 主键生成(36 位 UUID v4,转发到契约层)。 -//! -//! 🔴 真值源在 [`sspf_contract::ids`]。本文件只做转发,保持既有引用路径稳定。 -//! -//! 契约:规格 §「主键是 36 位 UUID v4(带连字符)」。 -//! `f_id` 存 `varchar(50)`,形状必须与基线平台一致,迁移期靠 `--data-only` 导数据。 +//! ids —— **转发壳**:真源在 [`sspf_core::ids`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_contract::ids::new_uuid; +pub use sspf_core::ids::*; diff --git a/src/backend/src/platform/menu.rs b/src/backend/src/platform/menu.rs index ba7bfcf..d8d9477 100644 --- a/src/backend/src/platform/menu.rs +++ b/src/backend/src/platform/menu.rs @@ -1,11 +1,5 @@ -//! menu —— **内置菜单 spec 的类型**(转发到契约层)。 -//! -//! 🔴 真值源在 [`sspf_contract::menu`](契约层)。本文件只做转发,保持既有引用路径稳定。 -//! -//! 🔴 **本文件只放「类型」,不放任何业务菜单** —— -//! 平台自带的那几条系统菜单在 [`crate::platform::seed`] 里, -//! **业务菜单**由业务包各自声明(`packs//` 的 `*_MENU`)。 -//! -//! 契约:`docs/contract.md` §8.4(内置菜单)。 +//! menu —— **转发壳**:真源在 [`sspf_core::menu`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_contract::menu::MenuSpec; +pub use sspf_core::menu::*; diff --git a/src/backend/src/platform/mod.rs b/src/backend/src/platform/mod.rs index c028a7a..5431a2f 100644 --- a/src/backend/src/platform/mod.rs +++ b/src/backend/src/platform/mod.rs @@ -1,5 +1,14 @@ //! platform —— **平台层**(框架自带,用户加业务时**基本不动这里**)。 //! +//! 🔴 **M2 起:这里只剩「转发壳」** —— 平台能力的实现全部下沉到 +//! [`sspf_core`](`crates/sspf-core/`),本目录的每个 `.rs` 只做 +//! `pub use sspf_core::<模块>::*`。 +//! +//! **为什么保留这一层**:既有 import 路径(`crate::platform::auth::…`)不变 +//! ⇒ 上层(`routes.rs` / `modules/` / 契约面 / 695 个测试)**零感知**。 +//! 一次性把全仓 import 改成 `sspf_core::…` 是「大爆炸」改动(编译器报几百处), +//! 而转发壳把风险面压到**一次编译** ⇒ 出错点唯一、可定位。 +//! //! 分层约定(对齐 `ssw-jnpf-lite-react` 的 `common/` + `auth/` + `sys/`, //! 以及官方 JNPF 的 `jnpf-common` + `jnpf-system`): //! @@ -12,6 +21,10 @@ //! //! 🔴 **平台层不许出现业务知识**(表名、app_code、菜单 key 一律不进平台层): //! 业务侧靠 [`entity::EntitySpec`] 把这些**声明**给引擎,引擎只读声明。 +//! +//! 🔴 **`compat/` 还在这里** —— 契约面(面 B)下沉是 M3/M4 的活; +//! 它**依赖** `sspf-core`(`AppState` / `Db` / `TokenUser`),方向单一(面 B ⇒ 平台核心)。 +//! ⚠️ 反方向(平台核心 ⇒ 面 B)**不许出现** —— 那是循环依赖,见 AR10。 pub mod auth; pub mod authorization; diff --git a/src/backend/src/platform/monitor.rs b/src/backend/src/platform/monitor.rs index e2fd480..81d8e7b 100644 --- a/src/backend/src/platform/monitor.rs +++ b/src/backend/src/platform/monitor.rs @@ -1,461 +1,5 @@ -//! monitor —— 宿主机资源快照(`GET /api/system/Monitor` 的唯一数据源)。 -//! -//! 🔴 **不许编数字**:不装 `sysinfo`(本仓不引第三方系统信息 crate),只用 -//! `libc`(**已是 workspace 依赖**,`main.rs` 用它转 fd)+ `std` 读真实内核数据: -//! -//! | 指标 | Linux | macOS | -//! |---|---|---| -//! | 内存 | `/proc/meminfo`(`MemTotal` / `MemAvailable`) | `sysctlbyname("hw.memsize")` + `vm.page_free_count` / `vm.page_speculative_count` × `hw.pagesize` | -//! | CPU 使用率 | `/proc/stat` **两次采样差分**(精确 tick) | `getloadavg()` 的 1 分钟负载 ÷ 逻辑核数(**近似**,见下) | -//! | 磁盘 | `statvfs("/")` | `statvfs("/")` | -//! | 型号 / 核数 | `/proc/cpuinfo` | `machdep.cpu.brand_string` / `hw.*cpu` | -//! | 运行时长 | 进程启动时刻(`Instant`) | 同左 | -//! | 本机 IP | UDP `connect` 后读 `local_addr()`(不发包) | 同左 | -//! -//! 🔴 **为什么 macOS 的 CPU 用负载均值**:精确占空比要 `host_statistics(HOST_CPU_LOAD_INFO)`, -//! 而它返回的 `host_t` 是 mach port —— 每 2 秒轮询一次就必须 `mach_port_deallocate`, -//! 否则进程的 send right 会一路涨。为一个仪表盘数字引入 mach port 生命周期管理 -//! 不划算 ⇒ 用 `getloadavg()[0] / 逻辑核数 × 100`(**内核维护的真实负载**, -//! 只是 1 分钟平滑值,不是瞬时占空比)。契约里这条标 `partial` 并写明这一点。 -//! -//! 🔴 官方 `MonitorUtil` 为了算占空比**在主线程 sleep 1 秒** —— 本仓不这么干 -//! (监控页每 2 秒轮询一次,每请求睡 1 秒等于把线程池拖死),改成**记住上一次快照**。 +//! monitor —— **转发壳**:真源在 [`sspf_core::monitor`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use std::sync::OnceLock; -use std::time::Instant; - -use serde_json::{json, Value}; - -/// 进程启动时刻(`system.day` 用的是**进程运行时长**,与官方 `RuntimeMXBean` 同义)。 -fn started_at() -> Instant { - static START: OnceLock = OnceLock::new(); - *START.get_or_init(Instant::now) -} - -/// 字节数 ⇒ 人话(对齐 hutool `FormatUtil.formatBytes`:1024 进制、两位小数)。 -pub fn human_bytes(bytes: u64) -> String { - const UNITS: [&str; 5] = ["B", "KB", "MB", "GB", "TB"]; - let mut value = bytes as f64; - let mut index = 0usize; - while value >= 1024.0 && index + 1 < UNITS.len() { - value /= 1024.0; - index += 1; - } - if index == 0 { - format!("{bytes} B") - } else { - format!("{value:.2} {}", UNITS[index]) - } -} - -/// 百分比 ⇒ 两位小数字符串(前端口径:`state.cpu.used == '0.00'` 判零)。 -fn pct(value: f64) -> String { - format!("{:.2}", value.clamp(0.0, 100.0)) -} - -/// 进程运行时长 ⇒ 「N天M小时 / M小时K分 / K分」(对齐 hutool `formatBetween(HOUR)` 的粒度)。 -fn human_uptime(secs: u64) -> String { - let days = secs / 86_400; - let hours = (secs % 86_400) / 3_600; - let minutes = (secs % 3_600) / 60; - if days > 0 { - format!("{days}天{hours}小时") - } else if hours > 0 { - format!("{hours}小时{minutes}分") - } else { - format!("{minutes}分") - } -} - -/// 本机出口 IP —— 用 UDP `connect` 让内核选路后读 `local_addr`(**不发任何包**)。 -fn local_ip() -> String { - std::net::UdpSocket::bind("0.0.0.0:0") - .and_then(|socket| { - socket.connect("8.8.8.8:80")?; - socket.local_addr() - }) - .map(|addr| addr.ip().to_string()) - .unwrap_or_default() -} - -/// 磁盘 `(total, available)`(字节)—— `statvfs("/")`,两平台通用。 -fn disk_usage() -> (u64, u64) { - let Ok(path) = std::ffi::CString::new("/") else { - return (0, 0); - }; - // SAFETY: `statvfs` 只写我们提供的这块栈内存,`path` 是合法的 NUL 结尾 C 串。 - let mut stat: libc::statvfs = unsafe { std::mem::zeroed() }; - let rc = unsafe { libc::statvfs(path.as_ptr(), &mut stat) }; - if rc != 0 { - return (0, 0); - } - let block = stat.f_frsize.max(1) as u64; - let total = block.saturating_mul(stat.f_blocks as u64); - let available = block.saturating_mul(stat.f_bavail as u64); - (total, available) -} - -/// 一次采样的原始值。 -struct Raw { - cpu_name: String, - cpu_package: u32, - cpu_cores: u32, - cpu_logical: u32, - /// 已用 CPU 百分比 —— Linux 是 tick 差分,macOS 是负载均值折算。 - cpu_used: f64, - mem_total: u64, - mem_available: u64, - os: String, -} - -// ---------------------------------------------------------------- Linux - -#[cfg(target_os = "linux")] -fn collect() -> Raw { - // --- CPU:`/proc/stat` 首行 8 个累计 tick,存进全局再差分 --- - static PREV: std::sync::Mutex> = std::sync::Mutex::new(None); - fn read_ticks() -> Option<[u64; 4]> { - let text = std::fs::read_to_string("/proc/stat").ok()?; - let line = text.lines().next()?; - let mut fields = line.split_whitespace(); - if fields.next()? != "cpu" { - return None; - } - let mut nums = [0u64; 8]; - for (index, slot) in nums.iter_mut().enumerate() { - *slot = fields.next().and_then(|v| v.parse().ok()).unwrap_or(0); - let _ = index; - } - // [user+nice, system+irq+softirq+steal, idle+iowait, 0] - Some([ - nums[0] + nums[1], - nums[2] + nums[5] + nums[6] + nums[7], - nums[3] + nums[4], - 0, - ]) - } - let current = read_ticks(); - let cpu_used = { - let mut guard = PREV.lock().unwrap_or_else(|e| e.into_inner()); - let used = match (current, *guard) { - (Some(now), Some(prev)) => { - let delta: Vec = now - .iter() - .zip(prev.iter()) - .map(|(a, b)| a.saturating_sub(*b)) - .collect(); - let total: u64 = delta.iter().sum(); - if total == 0 { - 0.0 - } else { - (delta[0] + delta[1]) as f64 * 100.0 / total as f64 - } - } - // 第一次调用没有基准 ⇒ 用开机以来的平均(与 OSHI 首帧口径一致) - (Some(now), None) => { - let total: u64 = now.iter().sum(); - if total == 0 { - 0.0 - } else { - (now[0] + now[1]) as f64 * 100.0 / total as f64 - } - } - _ => 0.0, - }; - *guard = current; - used - }; - - // --- 内存:`/proc/meminfo` 的两个 kB 字段 --- - let meminfo = std::fs::read_to_string("/proc/meminfo").unwrap_or_default(); - let pick = |key: &str| -> u64 { - meminfo - .lines() - .find(|line| line.starts_with(key)) - .and_then(|line| line.split_whitespace().nth(1)) - .and_then(|v| v.parse::().ok()) - .map(|kb| kb * 1024) - .unwrap_or(0) - }; - let mem_total = pick("MemTotal:"); - let mem_available = pick("MemAvailable:"); - - // --- CPU 型号 / 核数:`/proc/cpuinfo` --- - let cpuinfo = std::fs::read_to_string("/proc/cpuinfo").unwrap_or_default(); - let cpu_name = cpuinfo - .lines() - .find(|line| line.starts_with("model name")) - .and_then(|line| line.split(':').nth(1)) - .map(str::trim) - .unwrap_or("unknown") - .to_string(); - let cpu_logical = cpuinfo - .lines() - .filter(|line| line.starts_with("processor")) - .count() as u32; - let mut core_ids: Vec = cpuinfo - .lines() - .filter(|line| line.starts_with("core id")) - .filter_map(|line| line.split(':').nth(1).map(|v| v.trim().to_string())) - .collect(); - core_ids.sort(); - core_ids.dedup(); - let cpu_cores = if core_ids.is_empty() { - cpu_logical - } else { - core_ids.len() as u32 - }; - let cpu_package = cpuinfo - .lines() - .filter(|line| line.starts_with("physical id")) - .filter_map(|line| line.split(':').nth(1).map(|v| v.trim().to_string())) - .collect::>() - .len() - .max(1) as u32; - - // --- 发行版名(`/etc/os-release` 的 PRETTY_NAME) --- - let os = std::fs::read_to_string("/etc/os-release") - .ok() - .and_then(|text| { - text.lines() - .find(|line| line.starts_with("PRETTY_NAME=")) - .map(|line| { - line.trim_start_matches("PRETTY_NAME=") - .trim_matches('"') - .to_string() - }) - }) - .filter(|name| !name.is_empty()) - .unwrap_or_else(|| format!("Linux {}", std::env::consts::ARCH)); - - Raw { - cpu_name, - cpu_package, - cpu_cores: cpu_cores.max(1), - cpu_logical: cpu_logical.max(1), - cpu_used, - mem_total, - mem_available, - os, - } -} - -// ---------------------------------------------------------------- macOS - -#[cfg(target_os = "macos")] -mod macos { - use std::ffi::CString; - - extern "C" { - fn sysctlbyname( - name: *const i8, - oldp: *mut std::ffi::c_void, - oldlenp: *mut usize, - newp: *mut std::ffi::c_void, - newlen: usize, - ) -> i32; - } - - /// 读一个整数型 sysctl(`u32` / `u64` 都吃:缓冲区清零,内核只写它需要的宽度)。 - pub fn sysctl_int(name: &str) -> Option { - let cname = CString::new(name).ok()?; - let mut value: u64 = 0; - let mut size = std::mem::size_of::(); - // SAFETY: 传入的都是本栈上的合法缓冲区;`size` 是它们的真实长度。 - let rc = unsafe { - sysctlbyname( - cname.as_ptr(), - &mut value as *mut u64 as *mut std::ffi::c_void, - &mut size, - std::ptr::null_mut(), - 0, - ) - }; - if rc == 0 { - Some(value) - } else { - None - } - } - - /// 读一个字符串型 sysctl。 - pub fn sysctl_string(name: &str) -> Option { - let cname = CString::new(name).ok()?; - let mut buffer = [0u8; 256]; - let mut size = buffer.len(); - // SAFETY: 同上,`buffer` 是 256 字节的栈数组。 - let rc = unsafe { - sysctlbyname( - cname.as_ptr(), - buffer.as_mut_ptr() as *mut std::ffi::c_void, - &mut size, - std::ptr::null_mut(), - 0, - ) - }; - if rc != 0 { - return None; - } - let end = buffer.iter().position(|b| *b == 0).unwrap_or(size.min(256)); - Some(String::from_utf8_lossy(&buffer[..end]).trim().to_string()) - } -} - -#[cfg(target_os = "macos")] -fn collect() -> Raw { - use macos::{sysctl_int, sysctl_string}; - - // --- CPU:1 分钟负载 ÷ 逻辑核数(见模块头注释「为什么用负载均值」) --- - let logical = sysctl_int("hw.logicalcpu").unwrap_or(1).max(1) as f64; - let mut load = [0.0f64; 3]; - // SAFETY: `getloadavg` 只写调用方给的 3 个 double。 - let rc = unsafe { libc::getloadavg(load.as_mut_ptr(), 3) }; - let cpu_used = if rc < 0 { - 0.0 - } else { - (load[0] / logical * 100.0).clamp(0.0, 100.0) - }; - - // --- 内存:总容量 + 空闲/可回收页 × 页大小 --- - let page_size = sysctl_int("hw.pagesize").unwrap_or(4096); - let free_pages = sysctl_int("vm.page_free_count").unwrap_or(0); - let speculative = sysctl_int("vm.page_speculative_count").unwrap_or(0); - let mem_total = sysctl_int("hw.memsize").unwrap_or(0); - let mem_available = (free_pages + speculative).saturating_mul(page_size); - - let cpu_name = sysctl_string("machdep.cpu.brand_string").unwrap_or_else(|| "Apple CPU".to_string()); - let cpu_cores = sysctl_int("hw.physicalcpu").unwrap_or(1).max(1) as u32; - let cpu_package = sysctl_int("hw.packages").unwrap_or(1).max(1) as u32; - - let os = match sysctl_string("kern.osproductversion") { - Some(version) if !version.is_empty() => { - format!("macOS {version} ({})", std::env::consts::ARCH) - } - _ => format!("macOS ({})", std::env::consts::ARCH), - }; - - Raw { - cpu_name, - cpu_package, - cpu_cores, - cpu_logical: logical as u32, - cpu_used, - mem_total, - mem_available: mem_available.min(mem_total), - os, - } -} - -// ---------------------------------------------------------------- 其它平台 - -#[cfg(not(any(target_os = "linux", target_os = "macos")))] -fn collect() -> Raw { - Raw { - cpu_name: "unknown".to_string(), - cpu_package: 1, - cpu_cores: 1, - cpu_logical: 1, - cpu_used: 0.0, - mem_total: 0, - mem_available: 0, - os: format!("{} ({})", std::env::consts::OS, std::env::consts::ARCH), - } -} - -/// 组装 `MonitorListVO` 形状(与官方 `jnpf/base/model/monitor/MonitorListVO` 逐字段对齐)。 -/// -/// 🔴 字段**全是字符串**(除 `time` / `coreNumber`):官方 `FormatUtil` / `DecimalFormat` -/// 出来的就是 `"15.93 GB"` / `"12.34"` 这种文本,前端直接贴到模板里。 -pub fn payload() -> Value { - let raw = collect(); - let (disk_total, disk_available) = disk_usage(); - let mem_used = raw.mem_total.saturating_sub(raw.mem_available); - let mem_rate = if raw.mem_total == 0 { - 0.0 - } else { - mem_used as f64 * 100.0 / raw.mem_total as f64 - }; - let disk_used = disk_total.saturating_sub(disk_available); - let disk_rate = if disk_total == 0 { - 0.0 - } else { - disk_used as f64 * 100.0 / disk_total as f64 - }; - let uptime = started_at().elapsed().as_secs(); - - json!({ - "system": { - "os": raw.os, - "day": human_uptime(uptime), - "ip": local_ip(), - }, - "cpu": { - "name": raw.cpu_name, - "package": format!("{}个物理CPU", raw.cpu_package), - "core": format!("{}个物理核心", raw.cpu_cores), - "coreNumber": raw.cpu_cores, - "logic": format!("{}个逻辑CPU", raw.cpu_logical), - "used": pct(raw.cpu_used), - "idle": pct(100.0 - raw.cpu_used), - }, - "memory": { - "total": human_bytes(raw.mem_total), - "available": human_bytes(raw.mem_available), - "used": human_bytes(mem_used), - "usageRate": pct(mem_rate), - }, - "disk": { - "total": human_bytes(disk_total), - "available": human_bytes(disk_available), - "used": human_bytes(disk_used), - "usageRate": pct(disk_rate), - }, - "time": chrono::Utc::now().timestamp_millis(), - }) -} - -#[cfg(test)] -mod tests { - use super::*; - - /// 字节格式化:**1024 进制两位小数**(对齐 hutool `formatBytes`)。 - #[test] - fn human_bytes_matches_hutool_shape() { - assert_eq!(human_bytes(0), "0 B"); - assert_eq!(human_bytes(512), "512 B"); - assert_eq!(human_bytes(1024), "1.00 KB"); - assert_eq!(human_bytes(1024 * 1024 * 3 / 2), "1.50 MB"); - } - - /// 运行时长粒度:<1 小时只到分,<1 天到小时,>=1 天到天。 - #[test] - fn human_uptime_granularity() { - assert_eq!(human_uptime(90), "1分"); - assert_eq!(human_uptime(3 * 3600 + 120), "3小时2分"); - assert_eq!(human_uptime(2 * 86_400 + 5 * 3600), "2天5小时"); - } - - /// 🔴 **真采集**:本机跑测试时这些值必须是真的非零(不是占位 0)。 - /// 这条会把「采不到就填 0」的实现直接钉死 —— 0 就是失败。 - #[test] - fn payload_carries_real_host_metrics() { - let snap = payload(); - let mem_total = snap["memory"]["total"].as_str().unwrap_or_default(); - assert!( - mem_total != "0 B" && !mem_total.is_empty(), - "内存总量必须是真的(采不到会退化成 0 B):{mem_total}" - ); - let disk_total = snap["disk"]["total"].as_str().unwrap_or_default(); - assert!(disk_total != "0 B", "磁盘总量必须是真的:{disk_total}"); - let rate = snap["memory"]["usageRate"] - .as_str() - .unwrap_or_default() - .parse::() - .unwrap_or(-1.0); - assert!( - (0.0..=100.0).contains(&rate), - "内存使用率必须是 0..=100:{rate}" - ); - assert!(snap["time"].as_i64().unwrap_or(0) > 0, "时间戳必须是真的"); - } -} +pub use sspf_core::monitor::*; diff --git a/src/backend/src/platform/registry.rs b/src/backend/src/platform/registry.rs index a0d1bf7..3f0c214 100644 --- a/src/backend/src/platform/registry.rs +++ b/src/backend/src/platform/registry.rs @@ -1,200 +1,5 @@ -//! registry —— **多应用 / 多子系统**的注册表与路由(平台层)。 -//! -//! 契约:`docs/contract.md` §8.7(多应用)+ 官方 JNPF `base_system` / `App-Code`。 -//! -//! 🔴 **为什么叫 `registry` 而不是 `system`**:本仓的**契约面**按官方模块名组织 -//! (`compat/system.rs` = 官方面 B 的 system 端点集)。平台机制这一层要用 -//! **语义名**区分开 —— 它管的是「应用注册表」,不是「系统端点」。 -//! -//! 🔴 **机制(按官方 JNPF 平台做成多应用)**: -//! 1. **注册表** = `base_system` 表:每行一个应用,`f_en_code` 是该应用的 `App-Code`, -//! `f_id` 即下游所有 `base_module.f_system_id` 引用的系统 id; -//! 2. **路由** = 请求头 `App-Code` ⇒ [`app_code_of`] ⇒ [`resolve_system`] 解析出当前系统; -//! 3. **隔离** = `base_module` / 权限判据全部按 `f_system_id` 过滤 -//! (见 [`crate::platform::authorization`] / [`crate::platform::compat::helper::load_menus`])。 -//! -//! 🔴 **`App-Code` 不是契约判别头**:判别「面 A / 面 B」只看 `Vue-Version: 3` -//! (`JNPF_COMPAT_SURFACE.md` §2.2)。`App-Code` 只选「当前应用」,且本仓前端 -//! 也发它 ⇒ 它**绝不能**当判别头(见 `face_b.rs::is_face_b` 的注释)。 -//! -//! 🔴 **缺省 / 未命中 ⇒ 主系统**(`MAIN_SYSTEM_CODE`)—— 与官方 -//! `JnpfConst.MAIN_SYSTEM_CODE` 默认行为一致:没有 `App-Code` 或值不认识时, -//! 回落到主系统,绝不报错(避免「不认识的应用码 ⇒ 全站 500」)。 +//! registry —— **转发壳**:真源在 [`sspf_core::registry`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use axum::http::HeaderMap; - -use crate::platform::db::Db; - -/// 主系统的 id(`base_system.f_id`)。 -/// -/// 🔴 官方的主系统 `f_id` 是雪花号(初始化数据里是 `309228585019769285`), -/// 本仓用**可读字面量**自建种子(与内置菜单 id `m_sys` 同一风格); -/// 对外只承诺「`f_id` 稳定、下游 `f_system_id` 引用它」。 -pub const MAIN_SYSTEM_ID: &str = "mainSystem"; - -/// 主系统的编码(`base_system.f_en_code`,也即官方 `App-Code` 的值)。 -/// -/// 🔴 **官方常量**:`JnpfConst.MAIN_SYSTEM_CODE = "mainSystem"` -/// (`backend/jnpf-common/.../jnpf/constant/JnpfConst.java`)。 -/// 前端也硬比较这个值(`CollectPane.vue` / `CommonPane.vue` 里 -/// `systemCode === 'mainSystem'` 决定首页布局)⇒ **绝不能自造别的值**。 -pub const MAIN_SYSTEM_CODE: &str = "mainSystem"; - -/// 🔴 **选当前应用的请求头名**(官方 JNPF 用 `App-Code`;HTTP 头名大小写不敏感 ⇒ 小写)。 -pub const APP_CODE_HEADER: &str = "app-code"; - -/// 一个已解析出的系统引用。 -pub struct SystemRef { - /// 系统 id(`base_system.f_id`)—— 下游 `f_system_id` 引用它。 - pub id: String, - /// 系统编码(`base_system.f_en_code`,即 `App-Code`)。 - pub code: String, -} - -/// 从请求头读 `App-Code`(官方选当前应用的头;大小写不敏感,两侧空白忽略)。 -pub fn app_code_of(headers: &HeaderMap) -> Option { - headers - .get(APP_CODE_HEADER) - .and_then(|v| v.to_str().ok()) - .map(|v| v.trim().to_string()) - .filter(|s| !s.is_empty()) -} - -/// 🔴 **解析当前系统**: -/// - `App-Code` 命中 `base_system.f_en_code` ⇒ 返回该系统的 `(id, code)`; -/// - `App-Code` 缺失 ⇒ 按官方常量 [`MAIN_SYSTEM_CODE`] 查库(与显式传入完全同一条路径, -/// 这样即便部署方把主系统的 `f_id` 建成雪花号,`f_system_id` 也能对上); -/// - 未命中 / 查询失败 ⇒ 返回主系统常量(绝不报错、绝不 panic)。 -pub async fn resolve_system(db: &Db, app_code: Option<&str>) -> SystemRef { - let code = app_code.unwrap_or(MAIN_SYSTEM_CODE).to_string(); - let fallback = || SystemRef { - id: MAIN_SYSTEM_ID.to_string(), - code: MAIN_SYSTEM_CODE.to_string(), - }; - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\", f_en_code AS \"code\" FROM base_system \ - WHERE f_en_code = $1::text LIMIT 1", - &[&code], - ) - .await - { - Ok(rows) => rows, - Err(e) => { - // 🔴 DB 报错 ⇒ 回落主系统(不冒泡、不 panic;解析失败不应让请求挂掉)。 - eprintln!("[system] 系统解析失败(按主系统处理): {e}"); - return fallback(); - } - }; - if let Some(row) = rows.first() { - let id = row["id"].as_str().unwrap_or(MAIN_SYSTEM_ID).to_string(); - let code = row["code"].as_str().unwrap_or(MAIN_SYSTEM_CODE).to_string(); - if !id.is_empty() { - return SystemRef { id, code }; - } - } - // 未知应用码:回落到主系统(显式传入 mainSystem 时也走这条 ⇒ 结果一致)。 - fallback() -} - -/// 便捷封装:只取系统 id(权限 / 菜单隔离判据用)。 -pub async fn resolve_system_id(db: &Db, app_code: Option<&str>) -> String { - resolve_system(db, app_code).await.id -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::bootstrap; - use crate::platform::authorization::{self, MenuNode}; - use crate::platform::test_support; - - /// 多应用:注册表解析 + 菜单按系统隔离。 - /// - /// 🔴 单库单测(pglite 进程级全局 ⇒ 只开一次): - /// 1. 不传 / 不认识 `App-Code` ⇒ 回落主系统; - /// 2. `base_system` 多行(主系统 + app-b)可按 `App-Code` 解析; - /// 3. 菜单按 `f_system_id` 隔离 —— 主系统看不到 app-b 的菜单,反之亦然。 - #[tokio::test] - async fn registry_resolution_and_menu_isolation() { - // 🔴 用进程级共享实例(pglite 只能开一次;绝不能各模块各 open_temp 一次)。 - let db = test_support::shared_db().await; - // 🔴 经**装配根**种(平台层 ↔ 业务层只在装配根接线;测试与运行时共用同一入口, - // ⇒ 满足 check-boundary 的 CP5:平台层种子入口的调用点只在装配根)。 - bootstrap::ensure_base(db).await.expect("ensure_base"); - - // ---- 注册表解析 ---- - // 缺省 ⇒ 主系统。 - let s = resolve_system(&db, None).await; - assert_eq!(s.id, MAIN_SYSTEM_ID); - assert_eq!(s.code, MAIN_SYSTEM_CODE); - // 不认识的 App-Code ⇒ 仍回落主系统(绝不报错)。 - assert_eq!(resolve_system(&db, Some("no-such-app")).await.id, MAIN_SYSTEM_ID); - // 命中 app-b ⇒ 解析出 app-b 的 (id, code)。 - let s = resolve_system(&db, Some("app-b")).await; - assert_eq!(s.id, "app-b"); - assert_eq!(s.code, "app-b"); - - // ---- 在 app-b 下塞一条独立菜单(模拟「另一个应用」的菜单)---- - db.exec_params( - "INSERT INTO base_module \ - (f_id, f_full_name, f_en_code, f_url_address, f_parent_id, f_type, \ - f_sort_code, f_system_id, f_enabled_mark, f_delete_mark, f_tenant_id) \ - VALUES ($1::text,$2::text,$3::text,$4::text,$5::text,$6::text::integer, \ - $7::text::bigint,$8::text,$9::text::integer,$10::text::integer,$11::text)", - &[ - &"m_appb_x".to_string(), - &"应用B菜单".to_string(), - &"permission.appb.x".to_string(), - &"appb/x".to_string(), - &"0".to_string(), - &"2".to_string(), - &"1".to_string(), - &"app-b".to_string(), - &"1".to_string(), - &"0".to_string(), - &"0".to_string(), - ], - ) - .await - .expect("insert app-b menu"); - - // 主系统(admin 看全部):5 条内置 + **业务层声明的全部业务菜单**,且不含 app-b 的菜单。 - // 🔴 `build_menu_list` 返回的是**树的根节点**(不是扁平列表)—— 内置菜单挂在 - // `m_sys` 下 ⇒ 主系统的根节点比节点总数少。隔离断言必须用**展平集合**判断。 - // 🔴 这里**不写死业务菜单条数**(否则每加一个业务模块就得改平台层 ⇒ 违反 - // 「加模块只碰业务层」)⇒ 只钉「5 条内置必须在、且不含异系统菜单」。 - let main_menus = authorization::build_menu_list(&db, "admin", 1, MAIN_SYSTEM_ID).await; - let main_ids = flat_ids(&main_menus); - for builtin in ["m_sys", "m_user", "m_role", "m_org", "m_menu"] { - assert!( - main_ids.iter().any(|id| id == builtin), - "主系统必须含内置菜单 {builtin}" - ); - } - assert!( - main_ids.len() >= 5, - "主系统菜单数不应少于 5 条内置,实际 {}", - main_ids.len() - ); - assert!( - !main_ids.iter().any(|id| id == "m_appb_x"), - "主系统不应含 app-b 的菜单(隔离被破坏)" - ); - // app-b 系统:只含它自己的 1 条菜单(展平后仍是 1 个节点)。 - let appb_menus = authorization::build_menu_list(&db, "admin", 1, "app-b").await; - let appb_ids = flat_ids(&appb_menus); - assert_eq!(appb_ids.len(), 1, "app-b 系统应只有 1 个菜单节点"); - assert_eq!(appb_ids[0], "m_appb_x"); - } - - /// 把菜单树展平成「全部节点 id」列表(含根与所有后代)。 - fn flat_ids(nodes: &[MenuNode]) -> Vec { - let mut out = Vec::new(); - for n in nodes { - out.push(n.id.clone()); - out.extend(flat_ids(&n.children)); - } - out - } -} +pub use sspf_core::registry::*; diff --git a/src/backend/src/platform/route.rs b/src/backend/src/platform/route.rs index e5cef3b..7eff9e5 100644 --- a/src/backend/src/platform/route.rs +++ b/src/backend/src/platform/route.rs @@ -1,13 +1,5 @@ -//! route —— **业务包路由声明的类型**(转发到契约层)。 -//! -//! 🔴 真值源在 [`sspf_contract::route`](契约层)。本文件只做转发,保持既有引用路径稳定。 -//! -//! 🔴 **本文件只放「类型」,不放任何具体路由** —— -//! 业务包在自己的 `packs//src/lib.rs` 里声明路由, -//! 内核用 [`crate::platform::crud::crud_router`] 按声明**生成**路由。 -//! -//! 🔴 **路径形状**:必须是官方 JNPF 形状(`/api/{模块}/{资源}/...`), -//! **不许**用面 A 的 `/api/ssw/{appCode}/{Entity}/{List|Save|Delete}` -//! (那是本仓自造的 ssw 约定 ⇒ 集成到官方 JNPF 时**全部作废**)。 +//! route —— **转发壳**:真源在 [`sspf_core::route`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -pub use sspf_contract::route::{HttpMethod, PackRoute, RouteAction, RouteGuard}; +pub use sspf_core::route::*; diff --git a/src/backend/src/platform/seed.rs b/src/backend/src/platform/seed.rs index ee3a4c0..5846288 100644 --- a/src/backend/src/platform/seed.rs +++ b/src/backend/src/platform/seed.rs @@ -1,1107 +1,5 @@ -//! seed —— 两段式种子(`ensure_base` 幂等 + `first_seed` 首启)。 -//! -//! 契约:`docs/contract.md` §8.4(内置菜单)/ §8.5(内置角色)/ §8.6(种子行为)。 -//! -//! 两段式: -//! - [`ensure_base`]:**每次启动都跑**,幂等 —— 只补缺项,**绝不覆盖已改值**; -//! - [`first_seed`]:**仅当 `base_user` 行数为 0 时**跑一次 —— 建 admin 用户 + 角色关联。 -//! -//! 🔴 **不复活软删行**:内置角色 / 内置菜单的存在性判定**不按 `f_delete_mark` 过滤** -//! (契约 §8.6 明确要求)⇒ 用户手动软删的行不会被种子「复活」。 -//! 🔴 **授权行同理**:`base_authorize` 的「已授权」判定也不按 `f_delete_mark` 过滤 -//! ⇒ 软删的授权行也算「已授权」⇒ 不补。 -//! -//! 🔴 **存在性判定必须与固定字面量 id 对齐**:内置角色按 -//! 「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判,内置菜单按 -//! 「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判 —— -//! INSERT 用的是**固定字面量 id**(`role_admin` / `m_user` …),若只按 -//! en_code / url 判,用户在 UI 改过内置项的这两个字段后就会「查不到 ⇒ 撞复合主键」 -//! ⇒ 种子失败 ⇒ 进程 exit 1 ⇒ 此后每次启动都失败(且服务起不来 ⇒ 用户也没法用 UI 改回去)。 -//! -//! 🔴 **官方 DDL 陷阱**:`base_role_relation` **没有** `f_user_id` 列 —— 用户 id 存在 -//! `f_object_id`(配 `f_object_type='user'`);`base_user_relation` 才有 `f_user_id`。 -//! 写错列 ⇒ 授权永远不生效且**静默**。 -//! 🔴 7 张 `base_*` 表的主键是复合键 `(f_id, f_tenant_id)`,`f_tenant_id` 是 -//! `NOT NULL DEFAULT '0'` ⇒ **INSERT 必须显式写 `f_tenant_id='0'`**。 +//! seed —— **转发壳**:真源在 [`sspf_core::seed`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use crate::platform::cipher::md5_hex; -use crate::platform::db::{pglite, pglite::ToSql, Db}; -use crate::platform::ids::new_uuid; -use crate::platform::menu::MenuSpec; -use crate::platform::registry; - -/// 内置 admin 账号名(同时用作种子的 `f_creator_user_id`)。 -const ADMIN_ACCOUNT: &str = "admin"; - -/// 内置 admin 角色的 `f_en_code`(内置角色清单里 `admin` 的编码)。 -const ADMIN_ROLE_EN_CODE: &str = "admin"; - -/// 内置 admin 角色的**字面量** id(`first_seed` 的角色关联引用它)。 -const ADMIN_ROLE_ID: &str = "role_admin"; - -/// 内置角色(契约 §8.5)—— 逐字值,**不得改动**。 -const BUILTIN_ROLES: [BuiltinRole; 2] = [ - BuiltinRole { - id: "role_admin", - full_name: "管理员", - en_code: "admin", - sort_code: 1, - }, - BuiltinRole { - id: "role_user", - full_name: "使用者", - en_code: "user", - sort_code: 2, - }, -]; - -/// 🔴 **平台层自带的内置菜单**(契约 §8.4)—— 逐字值,**不得改动**。 -/// -/// 🔴 **只含「系统管理」那 5 条**(`system` / `system/User` / `system/Role` / -/// `system/Organize` / `system/Module`)—— 它们是**平台层自己的**菜单 -/// (平台层提供 `base_*` 的管理端点 ⇒ 菜单是平台层的资产)。 -/// -/// 🔴 **业务菜单不在这里**(`demo-item` / `shop/Product` / `books/Book` …)—— -/// 那是**业务知识** ⇒ 由业务层各自声明(`modules/.rs` 的 `*_MENU`) -/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 -/// -/// 🔴 **`en_code` 是面 B 的点权限判据**(官方 `@SaCheckPermission("permission.user")`) -/// —— 面 A 用 `f_url_address`、面 B 用 `f_en_code`,**两套并存**。 -const BUILTIN_MENUS: [MenuSpec; 5] = [ - MenuSpec { - id: "m_sys", - full_name: "系统管理", - en_code: "permission", - url_address: "system", - parent_id: "0", - menu_type: 1, - icon: Some("setting"), - sort_code: 1, - system_en_code: registry::MAIN_SYSTEM_CODE, - }, - MenuSpec { - id: "m_user", - full_name: "用户管理", - en_code: "permission.user", - url_address: "system/User", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 2, - system_en_code: registry::MAIN_SYSTEM_CODE, - }, - MenuSpec { - id: "m_role", - full_name: "角色管理", - en_code: "permission.role", - url_address: "system/Role", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 3, - system_en_code: registry::MAIN_SYSTEM_CODE, - }, - MenuSpec { - id: "m_org", - full_name: "机构管理", - en_code: "permission.organize", - url_address: "system/Organize", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 4, - system_en_code: registry::MAIN_SYSTEM_CODE, - }, - MenuSpec { - id: "m_menu", - full_name: "菜单管理", - en_code: "permission.menu", - url_address: "system/Module", - parent_id: "m_sys", - menu_type: 2, - icon: None, - sort_code: 5, - system_en_code: registry::MAIN_SYSTEM_CODE, - }, -]; - -/// 内置角色的一行(契约 §8.5)。 -struct BuiltinRole { - /// 字面量主键(`role_admin` / `role_user`)。 - id: &'static str, - /// 全名(`管理员` / `使用者`)。 - full_name: &'static str, - /// 编码(`admin` / `user`)—— **存在性判定的依据之一**(另一个是 `id`)。 - en_code: &'static str, - /// 排序码。 - sort_code: i64, -} - -/// 两段式种子的第一段:**补内置角色 / 内置菜单 / admin 授权**(幂等,每次启动都跑)。 -/// -/// 🔴 **`extra_menus` = 业务层声明的菜单**(`modules/.rs` 的 `*_MENU`)—— -/// 平台层**不认**任何业务菜单 ⇒ 业务菜单由**装配根** [`crate::bootstrap`] 传入 -/// ⇒ **加一个业务模块不用改平台层**(红线 12)。 -/// -/// 契约 §8.6。行为要点: -/// 1. 内置角色按「`f_en_code` 命中清单 **或** `f_id` = 固定字面量」判存在、 -/// 内置菜单按「`f_url_address` 命中清单 **或** `f_id` = 固定字面量」判存在 -/// —— 🔴 **都不按 `f_delete_mark` 过滤** ⇒ 软删行不被复活。 -/// 2. admin 授权按 `(f_object_type='role', f_object_id, f_item_type='module', f_item_id)` -/// 判存在 —— 🔴 同样**不按 `f_delete_mark` 过滤**。 -/// 3. **只补缺项,绝不覆盖已改值**(人工改名 / 调序 / 软删都会被保留)。 -pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite::Error> { - let now = now_str(); - ensure_systems(db, &now).await?; - ensure_builtin_roles(db, &now).await?; - let all_menus = all_builtin_menus(extra_menus); - ensure_builtin_menus(db, &now, &all_menus).await?; - ensure_admin_authorizations(db, &now, &all_menus).await?; - // 🔴 消息业务分类字典(`base_business_category`):消息记录页左侧两级页签的数据源。 - // 缺了它页面只是「页签为空」,不报错 ⇒ 很容易一直没人发现,所以放在同一处种。 - ensure_business_category(db, &now).await?; - // 🔴 `businessType` 字典:单据规则(模板中心)的「业务分类」列/下拉的唯一数据源。 - // 同样是「缺了不报错、只是全空」的那类,一并种在这里。 - ensure_business_type_dict(db, &now).await?; - // 🔴 数据建模的两张平台字典:基准数据类型 + 常用表字段。 - // 数据建模的新建表表单**完全依赖**前者(类型下拉),后者是「一键插入常用列」。 - // 同样是「缺了不报错、下拉全空」⇒ 一起种在这里。 - ensure_data_type(db, &now).await?; - ensure_common_fields(db, &now).await?; - // 🔴 `Language` 字典:多语言配置页的**表头**就是它(一个语种一列)。 - // 缺了它列表只剩「翻译标记」一列、新建表单也没有语种可填 ⇒ 页面等于废的。 - ensure_language_dict(db, &now).await?; - Ok(()) -} - -/// 多应用注册表(`base_system`)—— 幂等、每次启动都跑。 -/// -/// 🔴 MVP 多应用机制的核心:先确保**主系统**存在,再确保一个用于演示隔离的 -/// **第二应用 `app-b`** 存在(它**不带任何菜单** ⇒ 只验证「注册表 + 路由 + 隔离」, -/// 不引入业务菜单、不破 `check-boundary.sh` 的 CP6 平台层菜单条数断言)。 -/// -/// 🔴 **存在性判定** = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」,**不按 `f_delete_mark` -/// 过滤**(软删行也算存在 ⇒ 不复活、不覆盖、不撞复合主键)。 -/// -/// 🔴 业务新增一个应用 = 在 `base_system` 加一行 + 让对应 `MenuSpec.system_en_code` 指向它 -/// ⇒ **不用改本函数之外的平台代码**(平台只按 `en_code` 查 `f_id`)。 -pub async fn ensure_systems(db: &Db, now: &str) -> Result<(), pglite::Error> { - // (id, en_code = App-Code, full_name, f_is_main, description) - const BUILTIN_SYSTEMS: [(&str, &str, &str, i32, &str); 2] = [ - (registry::MAIN_SYSTEM_ID, registry::MAIN_SYSTEM_CODE, "系统平台", 1, "主系统"), - ("app-b", "app-b", "演示应用B", 0, "第二个应用(无菜单,用于验证隔离)"), - ]; - for (id, en_code, full_name, is_main, description) in BUILTIN_SYSTEMS { - let id = id.to_string(); - let en_code = en_code.to_string(); - let existing = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_system \ - WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1", - &[&en_code, &id], - ) - .await?; - if !existing.is_empty() { - continue; - } - let full_name = full_name.to_string(); - let is_main = is_main.to_string(); - let description = description.to_string(); - let enabled_mark = "1".to_string(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 11] = [ - &id, - &en_code, - &full_name, - &is_main, - &description, - &enabled_mark, - &sort_code, - &delete_mark, - &tenant_id, - &creator, - &now, - ]; - db.exec_params( - "INSERT INTO base_system \ - (f_id, f_en_code, f_full_name, f_is_main, f_description, f_enabled_mark, \ - f_sort_code, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text, \ - $6::text::integer, $7::text::bigint, $8::text::integer, \ - $9::text, $10::text, $11::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -/// 消息业务分类字典(`base_business_category`)—— 官方初始库里的**一级 + 二级**共 38 行。 -/// -/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 的 `INSERT INTO base_business_category` -/// (官方共 89 行;此处只取 `f_parent_id = '-1'` 的 5 个一级 + 其直接子级 33 个)。 -/// -/// 🔴 **id 沿用官方字面量**(雪花 id)—— 消息行的 `f_category` 存的是这些 id 的拼接, -/// id 一变,官方的历史消息就对不上分类。所以这 38 个 id **不得改动**。 -/// 🔴 **为什么不灌三级**:三级是「消息事件」粒度(`flow_todo_remind` 之类), -/// 本仓还没有产生消息的流程引擎 ⇒ 灌了也展示不到,只是 51 行死数据。 -/// 等真有消息落库再补(届时按官方 dump 续加到 [`BUSINESS_CATEGORIES`] 即可)。 -/// 🔴 `f_type` 官方种子一律 `0`(自定义分类才写 `1`,见 `BusinessCategoryController.addTag`)。 -const BUSINESS_CATEGORIES: [(&str, &str, &str, &str); 38] = [ - // ── 一级(`f_parent_id = '-1'`)──────────────────────────────── - ("2046493747218354176", "应用", "-1", "app"), - ("2046494412900536320", "流程", "-1", "flow"), - ("2046494560334516224", "系统", "-1", "sys"), - ("2046494646179336192", "公告", "-1", "announce"), - ("2046494880842256384", "其他", "-1", "other"), - // ── 二级 ────────────────────────────────────────────────────── - ("2046498207713857536", "应用授权", "2046493747218354176", "app_auth"), - ("2046498549667074048", "公告提醒", "2046494646179336192", "announce_remind"), - ("2046500072862126080", "签收提醒", "2046494412900536320", "flow_sign"), - ("2046500160736989184", "办理", "2046494412900536320", "flow_handle"), - ("2046500875702243328", "催办", "2046494412900536320", "flow_urge"), - ("2046501020737081344", "待办", "2046494412900536320", "flow_todo"), - ("2046501168506605568", "抄送", "2046494412900536320", "flow_cc"), - ("2046501319522521088", "转审", "2046494412900536320", "flow_transfer_review"), - ("2046501588842975232", "协办", "2046494412900536320", "flow_assist"), - ("2046501724960722944", "指派", "2046494412900536320", "flow_assign"), - ("2046501881433427968", "退回", "2046494412900536320", "flow_return"), - ("2046501986085507072", "撤销", "2046494412900536320", "flow_revoke"), - ("2046502107422527488", "超时", "2046494412900536320", "flow_timeout"), - ("2046502107422527491", "提醒", "2046494412900536320", "flow_notice"), - ("2046502333298380800", "异常", "2046494412900536320", "flow_exception"), - ("2046502439330385920", "评论", "2046494412900536320", "flow_comment"), - ("2046502572495343616", "同意", "2046494412900536320", "flow_approve"), - ("2046502674320461824", "结束", "2046494412900536320", "flow_end"), - ("2046502848119836672", "拒绝", "2046494412900536320", "flow_reject"), - ("2046502966558593024", "子流程", "2046494412900536320", "flow_subflow"), - ("2046503112767836160", "委托/代理通知", "2046494412900536320", "flow_delegate_rel"), - ("2046503688704495616", "委托操作通知", "2046494412900536320", "flow_delegate_op"), - ("2046504062601531392", "任务流通知", "2046494412900536320", "flow_notice_task"), - ("2046504062601531395", "决策流通知", "2046494412900536320", "flow_notice_decision"), - ("2046504380970176512", "流程编辑", "2046494412900536320", "flow_edit"), - ("2046504635065307136", "账户同步", "2046494560334516224", "sys_sync"), - ("2046504806578786304", "日程变更", "2046494560334516224", "sys_schedule_change"), - ("2046504806578786314", "日程邀请", "2046494560334516224", "sys_schedule_invite"), - ("2046505011386650624", "文档共享", "2046494560334516224", "sys_file"), - ("2046505115216646144", "运维安全", "2046494560334516224", "sys_operation"), - ("2046505268967247872", "登录安全", "2046494560334516224", "sys_login"), - ("2046505516032724992", "密码安全", "2046494560334516224", "sys_password"), - ("2058744163381415936", "消息通知", "2046494412900536320", "flow_message_notice"), -]; - -/// 灌业务分类字典 —— 幂等、每次启动都跑。 -/// -/// 🔴 **存在性按 `f_id` 判且不过滤 `f_delete_mark`**:管理员在 UI 里删掉某个分类 -/// (软删)后,这里不会再插回去 —— 与 [`ensure_base`] 的其余种子同一条口径。 -/// 🔴 顺序有意义:一级先插(`f_parent_id = '-1'`),二级引用它们 ⇒ 按常量里的 -/// 书写顺序插入即可(本常量就是一级在前)。 -pub async fn ensure_business_category(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 type_zero = "0".to_string(); - let delete_mark = "0".to_string(); - for (index, (id, full_name, parent_id, en_code)) in BUSINESS_CATEGORIES.iter().enumerate() { - let (id, full_name, parent_id) = - (id.to_string(), full_name.to_string(), parent_id.to_string()); - let (en_code, sort_code) = (en_code.to_string(), index.to_string()); - let existed = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_business_category WHERE f_id = $1::text LIMIT 1", - &[&id], - ) - .await?; - if !existed.is_empty() { - continue; - } - let params: [&(dyn ToSql + Sync); 10] = [ - &id, - &full_name, - &parent_id, - &en_code, - &enabled_mark, - &type_zero, - &sort_code, - &delete_mark, - &tenant_id, - &now, - ]; - db.exec_params( - "INSERT INTO base_business_category \ - (f_id, f_full_name, f_parent_id, f_en_code, f_enabled_mark, f_type, \ - 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::bigint, $8::text::integer, \ - $9::text, $10::text::timestamp)", - ¶ms, - ) - .await?; - } - 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"; - -/// `Language` 字典**分类**行的固定 id(官方初始库 `jnpf_db_init.sql` 同值)。 -const LANGUAGE_DICT_ID: &str = "dc6b2542d94b407cac61ec1d59592901"; - -/// `Language` 字典的语种行(官方初始库同 id / 同顺序)。 -/// -/// 🔴 **这就是多语言配置页的表头**:`base_language` 里一行的 `f_language` 必须命中 -/// 这里的某个 `enCode`,否则那行在列表里**没有列可以落**(会被静默丢掉)。 -const LANGUAGE_TYPES: [(&str, &str, &str, i64); 2] = [ - // (id, 显示名, enCode = 语种代码, 是否默认) - ("097a648ca21943c8ab775d169b893725", "简体中文", "zh-CN", 1), - ("e73047ef52f44d11b5326bf340981ed1", "English", "en-US", 0), -]; - -/// 灌 `Language` 字典(分类 1 行 + 语种 2 行)—— 幂等,按 `f_id` 判存在。 -/// -/// 🔴 与 [`ensure_business_type_dict`] 同一口径:**不看 `f_delete_mark`** -/// ⇒ 管理员在 UI 里删掉的语种不会被下次启动又插回来。 -pub async fn ensure_language_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 = LANGUAGE_DICT_ID.to_string(); - let dict_name = "系统语言".to_string(); - let dict_code = "Language".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, is_default)) in LANGUAGE_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 is_default = is_default.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); 12] = [ - &id, - &parent_zero, - &full_name, - &en_code, - &is_default, - &enabled_mark, - &dict_id, - &sort_code, - &delete_mark, - &tenant_id, - &now, - &sort_zero, - ]; - db.exec_params( - "INSERT INTO base_dictionary_data \ - (f_id, f_parent_id, f_full_name, f_en_code, f_is_default, f_enabled_mark, \ - f_dictionary_type_id, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time, \ - f_simple_spelling) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, \ - $6::text::integer, $7::text, $8::text::bigint, $9::text::integer, \ - $10::text, $11::text::timestamp, $12::text)", - ¶ms, - ) - .await?; - } - Ok(()) -} - - -/// 灌 `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(()) -} - -/// 基准数据类型(`base_data_type`)—— 官方初始库的 7 行原样。 -/// -/// 真源:`jnpf-database/PostgreSQL/jnpf_db_init.sql` 里 `base_data_type` 的 7 条 INSERT。 -/// 元组是 `(f_id, f_full_name, f_en_code)`,`f_type = 1`(系统)、`f_jnpf_key = NULL`。 -/// -/// 🔴 **为什么要灌它**:数据建模的「新建表」表单把类型下拉写死成 -/// `getBasicDataTypeList().map(o => ({fullName: o.fullName, id: o.enCode}))` -/// ⇒ 这张表为空时下拉**一个选项都没有**,表单虽然能打开但根本建不出表。 -/// 🔴 id 沿用官方雪花 id:`base_data_type_mapping` / `base_data_type_relation` -/// 都按这个 id 关联(本仓暂未建那两张,但先对齐,省得以后迁移对不上)。 -const DATA_TYPES: [(&str, &str, &str); 7] = [ - ("804009215168379011", "整型", "int"), - ("804009215168379013", "浮点型", "float"), - ("804009215168379014", "小数类型", "decimal"), - ("804009215168379016", "日期类型", "datetime"), - ("804009215168379017", "字符串", "varchar"), - ("804009215168379018", "文本", "text"), - ("804009215168379019", "长整形", "bigint"), -]; - -/// 常用表字段(`base_common_fields`)—— 官方初始库的 10 行原样。 -/// -/// 真源:`jnpf_db_init.sql` 里 `base_common_fields` 的 10 条 INSERT。 -/// 元组是 `(f_id, f_field_name, f_data_type, f_data_length, f_allow_null, f_field)`。 -/// -/// 🔴 官方这 10 行全是 `f_category = '2'`(**常用字段**)+ `f_type = 2`(自定义)+ -/// `f_enabled_mark = 1` + `f_allow_delete = NULL`(不是 0 —— 前端按 -/// `allowDelete === 0` 判「不许删」⇒ NULL 与 1 等价,都允许删)。 -const COMMON_FIELDS: [(&str, &str, &str, &str, &str, &str); 10] = [ - ("804368984903285110", "主键", "varchar", "50", "0", "f_id"), - ("804368984903285111", "描述", "varchar", "500", "1", "f_description"), - ("804368984903285112", "排序码", "bigint", "50", "1", "f_sort_code"), - ("804368984903285113", "有效标志", "int", "50", "1", "f_enabled_mark"), - ("804368984903285114", "创建时间", "datetime", "50", "1", "f_creator_time"), - ("804368984903285115", "创建用户", "varchar", "50", "1", "f_creator_user_id"), - ("804368984903285116", "修改时间", "datetime", "50", "1", "f_last_modify_time"), - ("804368984903285117", "修改用户", "varchar", "50", "1", "f_last_modify_user_id"), - ("804368984903285118", "删除时间", "datetime", "50", "1", "f_delete_time"), - ("804368984903285119", "删除用户", "varchar", "50", "1", "f_delete_user_id"), -]; - -/// 灌基准数据类型(7 行)—— 幂等,按 `f_id` 判存在。 -/// -/// 🔴 与其它种子同一口径:**不看 `f_delete_mark`**(管理员删掉的不会复活)。 -pub async fn ensure_data_type(db: &Db, now: &str) -> Result<(), pglite::Error> { - let now = now.to_string(); - let tenant_id = "0".to_string(); - let type_system = "1".to_string(); - let delete_mark = "0".to_string(); - for (index, (id, full_name, en_code)) in DATA_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_data_type WHERE f_id = $1::text LIMIT 1", - &[&id], - ) - .await?; - if !existed.is_empty() { - continue; - } - let params: [&(dyn ToSql + Sync); 8] = [ - &id, - &full_name, - &en_code, - &type_system, - &sort_code, - &delete_mark, - &tenant_id, - &now, - ]; - db.exec_params( - "INSERT INTO base_data_type \ - (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_delete_mark, f_tenant_id, \ - f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text::integer, $5::text::bigint, \ - $6::text::integer, $7::text, $8::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -/// 灌常用表字段(10 行)—— 幂等,按 `f_id` 判存在。 -pub async fn ensure_common_fields(db: &Db, now: &str) -> Result<(), pglite::Error> { - let now = now.to_string(); - let tenant_id = "0".to_string(); - let category = "2".to_string(); - let type_custom = "2".to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - for (index, (id, field_name, data_type, data_length, allow_null, field)) in - COMMON_FIELDS.iter().enumerate() - { - let (id, field_name, data_type) = (id.to_string(), field_name.to_string(), data_type.to_string()); - let (data_length, allow_null, field) = - (data_length.to_string(), allow_null.to_string(), field.to_string()); - let sort_code = index.to_string(); - let existed = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_common_fields WHERE f_id = $1::text LIMIT 1", - &[&id], - ) - .await?; - if !existed.is_empty() { - continue; - } - let params: [&(dyn ToSql + Sync); 13] = [ - &id, - &category, - &type_custom, - &field_name, - &data_type, - &data_length, - &allow_null, - &field, - &enabled_mark, - &sort_code, - &delete_mark, - &tenant_id, - &now, - ]; - db.exec_params( - "INSERT INTO base_common_fields \ - (f_id, f_category, f_type, f_field_name, f_data_type, f_data_length, f_allow_null, \ - f_field, f_enabled_mark, f_sort_code, f_delete_mark, f_tenant_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text::integer, $4::text, $5::text, $6::text, \ - $7::text::integer, $8::text, $9::text::integer, $10::text::bigint, \ - $11::text::integer, $12::text, $13::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -/// 把一个 `App-Code`(`base_system.f_en_code`)解析成系统 id(`base_system.f_id`)。 -/// -/// 🔴 用于把菜单种进正确的系统(`f_system_id`)—— 平台层**不认**具体 app 名, -/// 只按 `system_en_code` 去 `base_system` 查 ⇒ 业务声明属于哪个应用即可。 -/// 查不到 ⇒ 回落主系统 id(绝不报错)。 -async fn system_id_of(db: &Db, system_en_code: &str) -> String { - let en_code = system_en_code.to_string(); - let rows = match db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_system WHERE f_en_code = $1::text LIMIT 1", - &[&en_code], - ) - .await - { - Ok(r) => r, - Err(e) => { - eprintln!("[seed] 系统解析失败(按主系统处理): {e}"); - return registry::MAIN_SYSTEM_ID.to_string(); - } - }; - rows.first() - .and_then(|r| r["id"].as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string) - .unwrap_or_else(|| registry::MAIN_SYSTEM_ID.to_string()) -} - -/// 平台层自带菜单 + 业务层传入的菜单 = **本次要种的全部内置菜单**。 -/// -/// 🔴 顺序 = 平台层 5 条在前、业务菜单在后 ⇒ 菜单 id / `f_sort_code` 的 -/// 分配由**各自声明它的那一层**负责(平台层管 1–5,业务层管 6+)。 -fn all_builtin_menus(extra: &[MenuSpec]) -> Vec { - let mut all: Vec = BUILTIN_MENUS.to_vec(); - all.extend_from_slice(extra); - all -} - -/// 两段式种子的第二段:**首次启动**建 admin 用户 + 角色关联。 -/// -/// 契约 §8.6:**仅当 `base_user` 行数为 0 时**才跑(否则直接返回,什么都不做)。 -/// -/// 🔴 `admin_password` = admin 的**明文**口令(内部只算 md5,**永不外泄**)。 -/// 缺省走 [`crate::platform::config::DEFAULT_SEED_ADMIN_PASSWORD`](`123456`,契约逐字要求), -/// 生产档可用 `SEED_ADMIN_PASSWORD` env 覆盖。 -pub async fn first_seed(db: &Db, admin_password: &str) -> Result<(), pglite::Error> { - let count = db.scalar_text("SELECT count(*) FROM base_user").await?; - // 🔴 `count(*)` 恒有一行;万一查不到(None)也**不**种(宁可少种也不要重复 admin)。 - if count.as_deref() != Some("0") { - return Ok(()); - } - - let now = now_str(); - seed_admin_user(db, &now, admin_password).await?; - seed_admin_role_relation(db).await?; - Ok(()) -} - -// ---- 内置角色 ---- - -/// 补内置角色(按 `f_en_code` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 -async fn ensure_builtin_roles(db: &Db, now: &str) -> Result<(), pglite::Error> { - for role in BUILTIN_ROLES { - let id = role.id.to_string(); - let en_code = role.en_code.to_string(); - // 🔴 存在性判定 = 「`f_en_code` 命中 **或** `f_id` = 固定字面量」。 - // 只按 en_code 判会出事:用户把内置角色的 `f_en_code` 改掉后, - // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ - // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 - // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」。 - let existing = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role \ - WHERE f_en_code = $1::text OR f_id = $2::text LIMIT 1", - &[&en_code, &id], - ) - .await?; - if !existing.is_empty() { - continue; - } - - let full_name = role.full_name.to_string(); - let role_type = "user".to_string(); - let sort_code = role.sort_code.to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 10] = [ - &id, - &full_name, - &en_code, - &role_type, - &sort_code, - &enabled_mark, - &delete_mark, - &tenant_id, - &creator, - &now, - ]; - db.exec_params( - "INSERT INTO base_role \ - (f_id, f_full_name, f_en_code, f_type, f_sort_code, f_enabled_mark, \ - f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, $7::text::integer, $8::text, $9::text, \ - $10::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- 内置菜单 ---- - -/// 补内置菜单(按 `f_url_address` **或** `f_id` 判存在;含软删行 ⇒ 不复活、不覆盖)。 -/// -/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条(由 [`all_builtin_menus`] 拼好)。 -async fn ensure_builtin_menus( - db: &Db, - now: &str, - menus: &[MenuSpec], -) -> Result<(), pglite::Error> { - for menu in menus { - let id = menu.id.to_string(); - let url_address = menu.url_address.to_string(); - // 🔴 存在性判定 = 「`f_url_address` 命中 **或** `f_id` = 固定字面量」。 - // 只按 url 判会出事:用户把内置菜单的 `f_url_address` 改掉后, - // 下次启动会「查不到 ⇒ INSERT 固定 id」⇒ **撞复合主键** ⇒ 种子失败 ⇒ - // 进程 exit 1 ⇒ 此后每次启动都失败(服务起不来 ⇒ 用户也没法用 UI 改回去)。 - // 🔴 **不按 f_delete_mark 过滤** —— 软删行也算「已存在」(契约 §8.6 明确要求)。 - let existing = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_module \ - WHERE f_url_address = $1::text OR f_id = $2::text LIMIT 1", - &[&url_address, &id], - ) - .await?; - if !existing.is_empty() { - // 🔴 **存量库回填 `f_en_code` / `f_system_id`**:本仓早期版本的种子**不写** - // 这两列 ⇒ 存量库全是 NULL ⇒ 面 B 点权限判据落空(全站放行),且菜单无法按系统隔离。 - // 只在 **NULL 时**回填 ⇒ 人工改过的值不会被覆盖。 - let existing_id = existing - .first() - .and_then(|r| r["id"].as_str()) - .unwrap_or(id.as_str()) - .to_string(); - let en_code = menu.en_code.to_string(); - let system_id = system_id_of(db, menu.system_en_code).await; - db.exec_params( - "UPDATE base_module SET f_en_code = $1::text, f_system_id = $2::text \ - WHERE f_id = $3::text AND (f_en_code IS NULL OR f_system_id IS NULL)", - &[&en_code, &system_id, &existing_id], - ) - .await?; - continue; - } - - let full_name = menu.full_name.to_string(); - let en_code = menu.en_code.to_string(); - let parent_id = menu.parent_id.to_string(); - let menu_type = menu.menu_type.to_string(); - // 🔴 图标为 `None` ⇒ 写 **NULL**(契约 §8.4 的 `—`,不是空串)。 - let icon = menu.icon.map(str::to_string); - let sort_code = menu.sort_code.to_string(); - // 🔴 菜单按所属应用落 `f_system_id`(多应用隔离的落点)。 - let system_id = system_id_of(db, menu.system_en_code).await; - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 14] = [ - &id, - &full_name, - &en_code, - &url_address, - &parent_id, - &menu_type, - &icon, - &sort_code, - &system_id, - &enabled_mark, - &delete_mark, - &tenant_id, - &creator, - &now, - ]; - db.exec_params( - "INSERT INTO base_module \ - (f_id, f_full_name, f_en_code, f_url_address, f_parent_id, f_type, f_icon, f_sort_code, \ - f_system_id, f_enabled_mark, f_delete_mark, f_tenant_id, f_creator_user_id, f_creator_time) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, $7::text, \ - $8::text::bigint, $9::text, $10::text::integer, $11::text::integer, $12::text, \ - $13::text, $14::text::timestamp)", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- admin 授权 ---- - -/// 补 admin 角色对内置菜单的授权(只补缺项)。 -/// -/// 契约 §8.6: -/// - admin 角色行取 `f_en_code='admin'` 的**真实**行(🔴 不按 `f_delete_mark` 过滤, -/// 可能是用户自建的行 ⇒ id 不等于 `role_admin`); -/// - 待授权的菜单 = `f_delete_mark=0` **且** `f_url_address` 命中内置清单的行; -/// - 「已授权」判定 = `base_authorize` 中 -/// `f_object_type='role' AND f_object_id= AND f_item_type='module'` -/// 的**全部行**(🔴 不按 `f_delete_mark` 过滤)。 -/// -/// 🔴 `menus` = 平台层 5 条 + 业务层传入的 N 条 ⇒ admin 角色对**全部内置菜单** -/// 都有授权(契约 §8.6:内置 8 条菜单 ⇒ admin 8 条授权)。 -async fn ensure_admin_authorizations( - db: &Db, - now: &str, - menus: &[MenuSpec], -) -> Result<(), pglite::Error> { - // ---- 1) 取 admin 角色的真实行 ---- - let en_code = ADMIN_ROLE_EN_CODE.to_string(); - // 🔴 用的是**查到的真实行**(可能是用户自建的行 ⇒ id 不等于 `role_admin`)。 - // `f_en_code` 没有 UNIQUE 约束(应用层保证唯一)⇒ 万一有多行,按 `f_id` 取 - // 最小的那条,保证结果**确定**(同库多次跑 ⇒ 同一个 id)。 - let admin_roles = db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role WHERE f_en_code = $1::text \ - ORDER BY f_id LIMIT 1", - &[&en_code], - ) - .await?; - let Some(admin_role) = admin_roles.first() else { - // 没有 admin 角色 ⇒ 无从授权(`ensure_builtin_roles` 刚补过,除非被并发删了)。 - return Ok(()); - }; - let admin_role_id = admin_role["id"].as_str().unwrap_or_default().to_string(); - if admin_role_id.is_empty() { - return Ok(()); - } - - // ---- 2) 取内置菜单里「还活着」的行(f_delete_mark=0 且 url 命中清单)---- - let live_modules = db - .query_json( - "SELECT f_id AS \"id\", f_url_address AS \"urlAddress\" \ - FROM base_module WHERE f_delete_mark = 0", - ) - .await?; - let builtin_live: Vec = live_modules - .iter() - .filter(|row| { - row["urlAddress"] - .as_str() - .map(|url| menus.iter().any(|m| m.url_address == url)) - .unwrap_or(false) - }) - .filter_map(|row| row["id"].as_str().map(str::to_string)) - .collect(); - - // ---- 3) 取「已授权」的 f_item_id 集合 ---- - // - // 🔴 **不按 f_delete_mark 过滤** ⇒ 软删的授权行也算「已授权」⇒ 不补。 - let granted = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_object_id = $1::text \ - AND f_item_type = 'module'", - &[&admin_role_id], - ) - .await?; - let granted: Vec = granted - .iter() - .filter_map(|row| row["itemId"].as_str().map(str::to_string)) - .collect(); - - // ---- 4) 缺项 ⇒ 补一条授权 ---- - for menu_id in builtin_live { - if granted.iter().any(|g| g == &menu_id) { - continue; - } - let auth_id = new_uuid(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let params: [&(dyn ToSql + Sync); 7] = [ - &auth_id, - &admin_role_id, - &menu_id, - &sort_code, - &creator, - &now, - &delete_mark, - ]; - db.exec_params( - "INSERT INTO base_authorize \ - (f_id, f_object_type, f_object_id, f_item_type, f_item_id, f_sort_code, \ - f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, 'role', $2::text, 'module', $3::text, $4::text::bigint, \ - $5::text, $6::text::timestamp, $7::text::integer, '0')", - ¶ms, - ) - .await?; - } - Ok(()) -} - -// ---- 首启:admin 用户 + 角色关联 ---- - -/// 建 admin 用户(`f_password` = `md5_hex(admin_password)`)。 -/// -/// 🔴 `admin_password` 是**明文** ⇒ 立刻算 md5,**明文不进任何 SQL 参数、不进日志**。 -async fn seed_admin_user( - db: &Db, - now: &str, - admin_password: &str, -) -> Result<(), pglite::Error> { - let id = new_uuid(); - let account = ADMIN_ACCOUNT.to_string(); - let real_name = "管理员".to_string(); - let password = md5_hex(admin_password); - let is_administrator = "1".to_string(); - let organize_id = "0".to_string(); - let creator = ADMIN_ACCOUNT.to_string(); - let now = now.to_string(); - let enabled_mark = "1".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let params: [&(dyn ToSql + Sync); 11] = [ - &id, - &account, - &real_name, - &password, - &is_administrator, - &organize_id, - &creator, - &now, - &enabled_mark, - &delete_mark, - &tenant_id, - ]; - db.exec_params( - "INSERT INTO base_user \ - (f_id, f_account, f_real_name, f_password, f_is_administrator, f_organize_id, \ - f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark, f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::integer, $6::text, \ - $7::text, $8::text::timestamp, $9::text::integer, $10::text::integer, \ - $11::text)", - ¶ms, - ) - .await?; - Ok(()) -} - -/// 建 admin 的角色关联(`base_role_relation`)。 -/// -/// 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— 用户标识在 -/// `f_object_id`(配 `f_object_type='user'`);这里逐字用**账号名** `'admin'` -/// (react 源码里就是 `'admin'`,契约 §8.6 明确要求)。 -/// -/// 🔴 契约 §8.6 对这一行**逐字只列了 7 个字段**(`f_id` / `f_role_id` / `f_object_type` / -/// `f_object_id` / `f_sort_code` / `f_delete_mark` / `f_tenant_id`),**不含** -/// `f_creator_user_id` / `f_creator_time`(react 的 `roleRelRepo.save` 也不写这两列) -/// ⇒ 这里就**不写**(DDL 允许 NULL,不影响任何逻辑)。 -async fn seed_admin_role_relation(db: &Db) -> Result<(), pglite::Error> { - let id = new_uuid(); - let role_id = ADMIN_ROLE_ID.to_string(); - let object_type = "user".to_string(); - let object_id = ADMIN_ACCOUNT.to_string(); - let sort_code = "0".to_string(); - let delete_mark = "0".to_string(); - let tenant_id = "0".to_string(); - let params: [&(dyn ToSql + Sync); 7] = [ - &id, - &role_id, - &object_type, - &object_id, - &sort_code, - &delete_mark, - &tenant_id, - ]; - db.exec_params( - "INSERT INTO base_role_relation \ - (f_id, f_role_id, f_object_type, f_object_id, f_sort_code, f_delete_mark, \ - f_tenant_id) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text::bigint, \ - $6::text::integer, $7::text)", - ¶ms, - ) - .await?; - Ok(()) -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} +pub use sspf_core::seed::*; diff --git a/src/backend/src/platform/session.rs b/src/backend/src/platform/session.rs index 9a37ca9..36a4a44 100644 --- a/src/backend/src/platform/session.rs +++ b/src/backend/src/platform/session.rs @@ -1,451 +1,5 @@ -//! session —— 内存 token 会话表(进程内,进程重启即失效)。 -//! -//! 契约:登录成功后签发 token,后续请求带 `Authorization: bearer ` 解析出用户。 -//! -//! 🔴 **不用 Redis / Sa-Token**:本仓 v1 就是内存 token 表(与 JNPF 的 Sa-Token 内存模式同代)。 -//! -//! 🔴 **锁用 `std::sync::RwLock`**:访问全是同步的、无 await ⇒ 用 tokio 的锁会逼 `issue`/`resolve` -//! 变成 async,改变契约里定死的签名。 +//! session —— **转发壳**:真源在 [`sspf_core::session`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use std::collections::HashMap; -use std::sync::{Arc, RwLock}; - -use rand::Rng; - -use crate::platform::cipher::md5_hex; - -/// token 前缀(`"lite-"` + 32 个小写 hex ⇒ 总长 37)。 -const TOKEN_PREFIX: &str = "lite-"; - -/// `Authorization` 头里的 bearer 前缀(**含尾部空格**,共 7 字符)。 -const BEARER_PREFIX: &str = "bearer "; - -/// token 解析出来的用户信息。 -#[derive(Clone)] -pub struct TokenUser { - /// 用户主键(36 位 UUID v4)。 - pub user_id: String, - /// 登录账号。 - pub account: String, - /// 是否管理员(`base_user.f_is_administrator`,1 = 是)。 - pub is_admin: i32, - /// 签发时刻(毫秒时间戳,UTC)。在线用户页的「登录时间」来自这里。 - pub issued_at_ms: i64, - /// 登录 IP(取自 `X-Forwarded-For` / `X-Real-IP`;都没有 ⇒ 空串)。 - pub ip: String, - /// 登录 UA(原样保留,浏览器名由 `face_b` 现推)。 - pub user_agent: String, -} - -/// 内存 token 表:`token -> TokenUser`。 -#[derive(Clone, Default)] -pub struct SessionStore { - /// 🔴 放在 `Arc` 里:多个 handler 共享同一张表。 - inner: Arc>>, -} - -impl SessionStore { - /// 建一张空表。 - pub fn new() -> Self { - Self { - inner: Arc::new(RwLock::new(HashMap::new())), - } - } - - /// 签发一个 token,返回值形状 = `"lite-" + 32 个小写 hex`(总长 37)。 - /// - /// token = `"lite-" + md5(account + 毫秒时间戳 + 随机数)`。 - pub fn issue(&self, account: &str, user_id: &str, is_admin: i32) -> String { - self.issue_with_meta(account, user_id, is_admin, "", "") - } - - /// 同上,但一并记下**登录时的 IP 与 UA**(在线用户页要用)。 - /// - /// 🔴 分成两个方法而不是改 `issue` 的签名:`issue` 有十几个测试与夹具在用, - /// 为了「多记两列」把它们全改一遍不划算,也容易漏。 - pub fn issue_with_meta( - &self, - account: &str, - user_id: &str, - is_admin: i32, - ip: &str, - user_agent: &str, - ) -> String { - let millis = chrono::Utc::now().timestamp_millis(); - let rand: u64 = rand::thread_rng().gen(); - let digest = md5_hex(&format!("{}{}{}", account, millis, rand)); - - let token = format!("{}{}", TOKEN_PREFIX, digest); - let user = TokenUser { - user_id: user_id.to_string(), - account: account.to_string(), - is_admin, - issued_at_ms: millis, - ip: ip.to_string(), - user_agent: user_agent.to_string(), - }; - if let Ok(mut map) = self.inner.write() { - map.insert(token.clone(), user); - } - token - } - - /// 从 `Authorization` 头解析出用户。 - /// - /// - `None` / 空串 ⇒ `None`; - /// - 前 7 个字符大小写不敏感地命中 `"bearer "` ⇒ 截掉这 7 个字符查表; - /// - **不命中 ⇒ 整串当裸 token 查表**(有些客户端直接发裸 token); - /// - 查不到 ⇒ `None`。 - pub fn resolve(&self, auth_header: Option<&str>) -> Option { - let header = auth_header?.trim(); - if header.is_empty() { - return None; - } - - // 🔴 先看**前 7 个字节**:命中才截掉,否则整串当 token(大小写不敏感)。 - let bytes = header.as_bytes(); - let token = if bytes.len() >= BEARER_PREFIX.len() - && bytes[..BEARER_PREFIX.len()].eq_ignore_ascii_case(BEARER_PREFIX.as_bytes()) - { - &header[BEARER_PREFIX.len()..] - } else { - header - }; - if token.is_empty() { - return None; - } - - let map = self.inner.read().ok()?; - map.get(token).cloned() - } - - /// 全部会话的快照 `[(token, 用户)]`。 - /// - /// 🔴 **只在进程内用,别把 `token` 序列化给前端** —— 缓存管理页只用它算 - /// 「谁在线 / 有几条会话 / 占多少字节」,对外一律按**账号**聚合 - /// (见 `face_b.rs` 的 `cache_manage_list`)。 - pub fn snapshot(&self) -> Vec<(String, TokenUser)> { - match self.inner.read() { - Ok(map) => map.iter().map(|(k, v)| (k.clone(), v.clone())).collect(), - Err(_) => Vec::new(), - } - } - - /// 注销某账号的**全部**会话(「踢下线」),返回删掉的条数。 - pub fn revoke_account(&self, account: &str) -> usize { - match self.inner.write() { - Ok(mut map) => { - let before = map.len(); - map.retain(|_, u| u.account != account); - before - map.len() - } - Err(_) => 0, - } - } - - /// 注销**除某账号外**的全部会话,返回删掉的条数。 - /// - /// 对齐官方 `CacheManageController.clearAll` 的「跳过 token 前缀的键」—— - /// 清空缓存不该把自己这一条也清掉(否则点一下就被踢回登录页)。 - pub fn revoke_except(&self, account: &str) -> usize { - match self.inner.write() { - Ok(mut map) => { - let before = map.len(); - map.retain(|_, u| u.account == account); - before - map.len() - } - Err(_) => 0, - } - } - - /// 给**已签发**的会话补记登录元信息(IP / UA),返回是否命中。 - /// - /// 🔴 为什么不在 `issue` 时就传:`login_from_bytes` 有十几个测试在用, - /// 改它的签名要动一片;而登录 handler 拿到 token 之后再回调一次最省事, - /// **只影响真实 HTTP 路径**(测试直接调 `login_from_bytes` 的就只有空元信息)。 - pub fn annotate(&self, token: &str, ip: &str, user_agent: &str) -> bool { - match self.inner.write() { - Ok(mut map) => match map.get_mut(token) { - Some(user) => { - user.ip = ip.to_string(); - user.user_agent = user_agent.to_string(); - true - } - None => false, - }, - Err(_) => false, - } - } - - /// 按**会话指纹**注销单条会话,返回是否真的删掉了一条。 - pub fn revoke_by_fingerprint(&self, fingerprint: &str) -> bool { - let target = fingerprint.trim().to_lowercase(); - if target.is_empty() { - return false; - } - match self.inner.write() { - Ok(mut map) => { - let hit = map - .keys() - .find(|token| fingerprint_of(token) == target) - .cloned(); - match hit { - Some(token) => map.remove(&token).is_some(), - None => false, - } - } - Err(_) => false, - } - } - - /// 注销这些**用户主键**名下的全部会话(角色变更后「踢下线」用),返回删掉的条数。 - pub fn revoke_user_ids(&self, ids: &[String]) -> usize { - if ids.is_empty() { - return 0; - } - match self.inner.write() { - Ok(mut map) => { - let before = map.len(); - map.retain(|_, u| !ids.iter().any(|id| id == &u.user_id)); - before - map.len() - } - Err(_) => 0, - } - } -} - -/// 会话**指纹**:`md5(token)` 的 32 位小写 hex。 -/// -/// 🔴 **在线用户页对外只给指纹,绝不给真 token**:官方把 Sa-Token 的 token 当 -/// 「在线用户 id」直接返回(`UserOnlineController.java:58` `vo.setUserId(online.getToken())`), -/// 而管理员能看到**所有人**的 token ⇒ 等于能冒充任何人。指纹是单向的, -/// 前端拿它回传 `DELETE /{fingerprint}` 照样能精确踢人。 -pub fn fingerprint_of(token: &str) -> String { - md5_hex(token) -} - -// ================================================================ 票据(ticket) -// -// 🔴 **官方出处**:`LoginController.java:383`(`getTicket`)/ `:398`(`getTicketStatus`) -// / `:454`(`codeCertificate`)/ `:468`(`codeCertificateStatus`) -// / `:507`(`setCodeCertificateStatus`)。 -// -// 🔴 **官方用 Redis 存票据**(`TicketUtil.createTicket` / `parseTicket` / `updateTicket`) -// ⇒ 本仓**无 Redis** ⇒ 照 `SessionStore` 的同款做法:**进程内内存表** -// (进程重启即失效 —— 与本仓 token 表同一口径,不假装能跨重启)。 -// -// 🔴 **为什么不塞进 token 表**:票据载荷(状态 / 超时 / 值)与 token(用户身份) -// 生命周期与语义都不同 ⇒ 混在一张表里会让「注销会话」误删票据。 - -/// 票据的**种类**。 -#[derive(Clone, Copy, PartialEq, Eq, Debug)] -pub enum TicketKind { - /// 免密登录票据(`getTicket` / `getTicketStatus`)。 - Login, - /// 扫码登录凭证(`codeCertificate` / `codeCertificateStatus` / `setCodeCertificateStatus`)。 - ScanCode, -} - -impl TicketKind { - /// 票据串前缀 —— 两种票据**不能互相串用**(官方也是两张不同的 Redis key)。 - fn prefix(&self) -> &'static str { - match self { - TicketKind::Login => "tkt-", - TicketKind::ScanCode => "scc-", - } - } -} - -/// 一张票据的内容。 -#[derive(Clone, Debug)] -pub struct Ticket { - /// 票据种类。 - pub kind: TicketKind, - /// 状态码(官方 `LoginTicketStatus` / `ScanCodeTicketStatus` 的整数值)。 - pub status: i32, - /// 附带值(官方 `LoginTicketModel.value` —— 扫码确认后放登录 token)。 - pub value: String, - /// 主题(官方 `LoginTicketModel.theme`)。 - pub theme: String, - /// 过期时刻(毫秒时间戳,UTC)—— 对应官方 `ticketTimeout`。 - pub expires_at_ms: i64, -} - -impl Ticket { - /// 是否已过期。 - pub fn is_expired(&self, now_ms: i64) -> bool { - now_ms >= self.expires_at_ms - } -} - -/// 内存票据表:`票据串 -> Ticket`。 -#[derive(Clone, Default)] -pub struct TicketStore { - inner: Arc>>, -} - -impl TicketStore { - /// 建一张空表。 - pub fn new() -> Self { - Self { - inner: Arc::new(RwLock::new(HashMap::new())), - } - } - - /// 签发票据,返回票据串。 - /// - /// 🔴 票据串 = 前缀 + `md5(种类 + 毫秒时间戳 + 随机数)`(与 token 同一套手法)。 - pub fn issue(&self, kind: TicketKind, status: i32, ttl_seconds: i64) -> (String, i64) { - let now_ms = chrono::Utc::now().timestamp_millis(); - let rand: u64 = rand::thread_rng().gen(); - let digest = md5_hex(&format!("{:?}{}{}", kind, now_ms, rand)); - let ticket = format!("{}{}", kind.prefix(), digest); - let expires_at_ms = now_ms + ttl_seconds * 1000; - if let Ok(mut map) = self.inner.write() { - map.insert( - ticket.clone(), - Ticket { - kind, - status, - value: String::new(), - theme: String::new(), - expires_at_ms, - }, - ); - } - (ticket, expires_at_ms) - } - - /// 读票据;**过期即删**(官方 `parseTicket` 同样会判超时)。 - pub fn get(&self, kind: TicketKind, ticket: &str) -> Option { - let ticket = ticket.trim(); - if ticket.is_empty() { - return None; - } - let now_ms = chrono::Utc::now().timestamp_millis(); - let map = self.inner.read().ok()?; - let found = map.get(ticket).cloned()?; - // 🔴 种类不符 ⇒ 当作不存在(两种票据不能串用)。 - if found.kind != kind { - return None; - } - if found.is_expired(now_ms) { - drop(map); - self.remove(ticket); - return None; - } - Some(found) - } - - /// 更新票据的**状态 / 值**(官方 `TicketUtil.updateTicket`)。 - pub fn update(&self, kind: TicketKind, ticket: &str, status: i32, value: &str, ttl_seconds: i64) -> Option { - let ticket = ticket.trim(); - if ticket.is_empty() { - return None; - } - let now_ms = chrono::Utc::now().timestamp_millis(); - let mut map = self.inner.write().ok()?; - let entry = map.get_mut(ticket)?; - if entry.kind != kind { - return None; - } - entry.status = status; - if !value.is_empty() { - entry.value = value.to_string(); - } - entry.expires_at_ms = now_ms + ttl_seconds * 1000; - Some(entry.clone()) - } - - /// 删一张票据(官方 `TicketUtil.deleteTicket`)。 - pub fn remove(&self, ticket: &str) -> bool { - match self.inner.write() { - Ok(mut map) => map.remove(ticket.trim()).is_some(), - Err(_) => false, - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// token 形状:`"lite-"` 前缀 + 32 个小写 hex ⇒ 总长 37。 - #[test] - fn issued_token_shape() { - let store = SessionStore::new(); - let token = store.issue("admin", "uid-1", 1); - assert!(token.starts_with(TOKEN_PREFIX), "前缀必须是 lite-:{token}"); - let hex = &token[TOKEN_PREFIX.len()..]; - assert_eq!(hex.len(), 32, "必须是 32 个 hex 字符:{token}"); - assert_eq!(token.len(), 37, "总长必须是 37:{token}"); - assert!( - hex.chars().all(|c| c.is_ascii_digit() || ('a'..='f').contains(&c)), - "必须是小写 hex:{token}" - ); - } - - /// 签发后用 `bearer ` 能解析出正确的用户信息。 - #[test] - fn resolve_with_bearer_prefix() { - let store = SessionStore::new(); - let token = store.issue("zhangsan", "uid-abc", 0); - let got = store.resolve(Some(&format!("bearer {}", token))); - let user = got.expect("bearer 前缀必须能解析"); - assert_eq!(user.account, "zhangsan"); - assert_eq!(user.user_id, "uid-abc"); - assert_eq!(user.is_admin, 0); - } - - /// 前缀大小写不敏感(`BEARER` / `BeArEr` 都行)。 - #[test] - fn resolve_prefix_is_case_insensitive() { - let store = SessionStore::new(); - let token = store.issue("lisi", "uid-def", 1); - for prefix in ["BEARER ", "Bearer ", "beArEr "] { - let got = store.resolve(Some(&format!("{}{}", prefix, token))); - let user = got.unwrap_or_else(|| panic!("前缀 {} 必须能解析", prefix)); - assert_eq!(user.account, "lisi"); - assert_eq!(user.user_id, "uid-def"); - assert_eq!(user.is_admin, 1); - } - } - - /// 裸 token(不带前缀)也能解析。 - #[test] - fn resolve_bare_token() { - let store = SessionStore::new(); - let token = store.issue("wangwu", "uid-ghi", 0); - let got = store.resolve(Some(&token)); - assert_eq!(got.map(|u| u.account), Some("wangwu".to_string())); - } - - /// `None` / 空串 / 查不到的 token ⇒ `None`。 - #[test] - fn resolve_rejects_invalid() { - let store = SessionStore::new(); - assert!(store.resolve(None).is_none()); - assert!(store.resolve(Some("")).is_none()); - assert!(store.resolve(Some("bearer nope")).is_none()); - assert!(store.resolve(Some("nope")).is_none()); - } - - /// 两个不同签发的 token 互不干扰。 - #[test] - fn distinct_tokens_do_not_interfere() { - let store = SessionStore::new(); - let t1 = store.issue("u1", "id-1", 0); - let t2 = store.issue("u2", "id-2", 1); - assert_ne!(t1, t2, "两次签发不得相同"); - assert_eq!(store.resolve(Some(&t1)).map(|u| u.account), Some("u1".to_string())); - assert_eq!(store.resolve(Some(&t2)).map(|u| u.account), Some("u2".to_string())); - assert_eq!(store.resolve(Some(&t2)).map(|u| u.is_admin), Some(1)); - } - - /// `Default` 与 `new()` 等价(都能当空表用)。 - #[test] - fn default_is_empty_store() { - let store = SessionStore::default(); - assert!(store.resolve(Some("lite-whatever")).is_none()); - } -} +pub use sspf_core::session::*; diff --git a/src/backend/src/platform/state.rs b/src/backend/src/platform/state.rs index 90af298..4e87111 100644 --- a/src/backend/src/platform/state.rs +++ b/src/backend/src/platform/state.rs @@ -1,44 +1,5 @@ -//! state —— 全局应用状态(axum `Router` 的 `State`)。 -//! -//! 契约:规格 §9「AppState」。 -//! -//! 🔴 `config` 必须装在 `Arc` 里(`Config` 每次克隆都要复制 `PathBuf`), -//! 🔴 `db` 按契约写死 `Arc`(虽然 `Db` 本身是 `Clone`,但契约形状不改)。 -//! 🔴 `sessions` 用 `Arc` ⇒ 多 handler 共享同一张 token 表。 +//! state —— **转发壳**:真源在 [`sspf_core::state`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use std::sync::Arc; - -use crate::platform::config::Config; -use crate::platform::db::Db; -use crate::platform::session::{SessionStore, TicketStore}; - -/// 全局应用状态。 -#[derive(Clone)] -pub struct AppState { - /// 运行时配置(端口 / 数据目录 / 静态目录)。 - pub config: Arc, - /// pglite 封装。 - pub db: Arc, - /// 内存 token 会话表。 - pub sessions: Arc, - /// 🔴 内存票据表(免密登录票据 / 扫码凭证)。 - /// - /// 🔴 **官方出处**:`LoginController.java:383`(`getTicket`)/ `:398` - /// (`getTicketStatus`)/ `:454`(`codeCertificate`)/ `:468` - /// (`codeCertificateStatus`)/ `:507`(`setCodeCertificateStatus`)。 - /// 官方用 Redis 存 ⇒ 本仓无 Redis ⇒ 照 token 表的同款做法用**进程内内存表** - /// (进程重启即失效,不假装能跨重启)。 - pub tickets: Arc, -} - -#[cfg(test)] -mod tests { - use super::*; - - /// axum `State` 要求 `Clone + Send + Sync + 'static` —— 编译期钉住。 - #[test] - fn app_state_satisfies_axum_state_bounds() { - fn assert_state_bounds() {} - assert_state_bounds::(); - } -} +pub use sspf_core::state::*; diff --git a/src/backend/src/platform/sys.rs b/src/backend/src/platform/sys.rs index 7b7c43c..858bfea 100644 --- a/src/backend/src/platform/sys.rs +++ b/src/backend/src/platform/sys.rs @@ -1,1295 +1,5 @@ -//! sys —— 5 组 `base_*` CRUD(User / Role / Organize / Module)+ 授权写入。 -//! -//! 契约:`docs/contract.md` §6.2 / §6.3(端点)+ §7.1–§7.5(语义)+ §7.7(唯一刻意偏离)。 -//! 行为真源:`~/Desktop/workspace/skills/ssw-jnpf-lite-react/src/backend/src/sys/sys.service.ts` -//! 与 `.../sys/authorize.controller.ts`。 -//! -//! 🔴 **七条硬约定**: -//! 1. **业务失败恒 HTTP 200**(信封里的 `code=400`);DB 报错 ⇒ `系统异常,请联系管理员` -//! (真因只进服务端日志,**不外泄**)。 -//! 2. **不得 `SELECT *`**:每列显式 `AS ""`(**带双引号** —— PG 会把未加引号的 -//! 标识符折叠成小写 ⇒ `row_to_json` 出来的键会变成 `realname` ⇒ 前端读不到,且**静默**)。 -//! 3. **口令不得外泄**:`base_user` 的读回投影**根本不选 `f_password`** -//! (比「选了再删」更安全)⇒ List / Save 响应里**没有 `password` 键**。 -//! 4. **标识符白名单 + 参数化**:动态拼的表名/列名先过 `db::valid_table` / `db::valid_column`; -//! **所有用户数据**走绑定参数,绝不拼进 SQL 文本。 -//! 5. **只 SET body 里出现的键**(react / TypeORM `save` 的 `undefined` 语义,裁决 S16)。 -//! 🔴 这条保护 `base_module.f_url_address`(权限守卫的比对键)不被误清成 NULL。 -//! 6. **多步写用 data-modifying CTE 合成一条语句**(裁决 P59)⇒ 一条语句 = 一个隐式事务 = 原子。 -//! 7. **非测试代码零 `unwrap()` / `expect()` / `panic!()`**。 +//! sys —— **转发壳**:真源在 [`sspf_core::sys`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -use std::collections::HashMap; - -use axum::body::Bytes; -use axum::extract::{Path, RawQuery, State}; -use axum::http::HeaderMap; -use axum::Json; -use serde_json::{json, Map, Value}; - -use crate::platform::auth::{require_login, require_login_any, require_module}; -use crate::platform::cipher::md5_hex; -use crate::platform::db::{self, pglite, pglite::ToSql, Db}; -use crate::platform::envelope::{fail, ok, ActionResult}; -use crate::platform::ids::new_uuid; -use crate::platform::state::AppState; - -// ---------------------------------------------------------------- 菜单守卫 key - -const USER_MODULE: &str = "system/User"; -const ROLE_MODULE: &str = "system/Role"; -const ORGANIZE_MODULE: &str = "system/Organize"; -const MODULE_MODULE: &str = "system/Module"; - -// ---------------------------------------------------------------- 投影列(契约 §5.3) - -/// `base_user` 的读回投影(12 列)—— 🔴 **不含 `f_password`**(R1.6:根本不选它)。 -const USER_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_account AS "account", -f_real_name AS "realName", f_secretkey AS "secretkey", -f_is_administrator AS "isAdministrator", f_role_id AS "roleId", -f_organize_id AS "organizeId", f_creator_user_id AS "creatorUserId", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_enabled_mark AS "enabledMark", f_delete_mark AS "deleteMark""#; - -/// `base_role` 的读回投影(11 列)。 -const ROLE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_en_code AS "enCode", f_type AS "type", f_description AS "description", -f_enabled_mark AS "enabledMark", f_sort_code AS "sortCode", -f_creator_user_id AS "creatorUserId", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -/// `base_organize` 的读回投影(11 列)—— 🔴 **没有 `f_creator_user_id`**。 -const ORGANIZE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_parent_id AS "parentId", f_category AS "category", f_en_code AS "enCode", -f_manager_id AS "managerId", f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -/// `base_module` 的读回投影(13 列)—— 🔴 **没有 `f_creator_user_id`**。 -const MODULE_COLUMNS: &str = r#"f_id AS "id", f_tenant_id AS "tenantId", f_full_name AS "fullName", -f_url_address AS "urlAddress", f_parent_id AS "parentId", f_type AS "type", -f_category AS "category", f_en_code AS "enCode", f_icon AS "icon", -f_sort_code AS "sortCode", f_enabled_mark AS "enabledMark", -to_char(f_creator_time, 'YYYY-MM-DD"T"HH24:MI:SS') || 'Z' AS "creatorTime", -f_delete_mark AS "deleteMark""#; - -// ---------------------------------------------------------------- 通用小工具 - -/// DB 报错 ⇒ 统一文案(契约 §R1.2 / §6.5)。 -fn db_error(e: pglite::Error, ctx: &str) -> Json { - eprintln!("[sys] {ctx}失败: {e}"); - fail(400, "系统异常,请联系管理员") -} - -/// 当前 UTC 朴素时间 ⇒ `YYYY-MM-DD HH:MM:SS`(PG `TIMESTAMP(0)` 是秒精度、无时区)。 -fn now_str() -> String { - chrono::Utc::now() - .naive_utc() - .format("%Y-%m-%d %H:%M:%S") - .to_string() -} - -/// 解析 JSON body;失败 ⇒ `fail(400, "请求参数格式错误")`(裁决 P61)。 -/// -/// 🔴 **不用 axum 的 `Json`**:它的解析失败会返回 **422 + 非信封 body** ⇒ 契约破。 -fn parse_body(body: &Bytes) -> Result> { - match serde_json::from_slice::(body) { - Ok(v) => Ok(v), - Err(_) => Err(fail(400, "请求参数格式错误")), - } -} - -/// 取 body 里的对象;**不是对象 ⇒ 空对象**(⇒ 走「参数缺失」的业务文案分支)。 -fn body_object(body: &Bytes) -> Result, Json> { - let v = parse_body(body)?; - Ok(match v { - Value::Object(m) => m, - _ => Map::new(), - }) -} - -/// 取 query 参数;**缺失 / 解析失败 ⇒ 空串**(视作「参数缺失」)。 -/// -/// 🔴 **不用 axum 的 `Query`**:它的解析失败会返回 **400 + 非信封 body** ⇒ 契约破。 -/// -/// 🔴 `pub(crate)` —— 面 B 的 `face_b` 模块也要用它(官方分页参数 `currentPage` / `pageSize`)。 -pub(crate) fn query_param(raw: &RawQuery, key: &str) -> String { - let Some(q) = raw.0.as_deref() else { - return String::new(); - }; - let pairs: Vec<(String, String)> = serde_urlencoded::from_str(q).unwrap_or_default(); - pairs - .into_iter() - .find(|(k, _)| k == key) - .map(|(_, v)| v) - .unwrap_or_default() -} - -/// JS 真值判定(react 的 `dto.isAdministrator ? 1 : 0`)。 -fn truthy(v: Option<&Value>) -> bool { - match v { - None | Some(Value::Null) => false, - Some(Value::Bool(b)) => *b, - Some(Value::Number(n)) => n.as_f64().map(|f| f != 0.0).unwrap_or(false), - Some(Value::String(s)) => !s.is_empty(), - Some(Value::Array(a)) => !a.is_empty(), - Some(Value::Object(o)) => !o.is_empty(), - } -} - -/// `body.organizeId || '0'` / `body.parentId || '0'` 的 JS `||` 语义。 -fn or_zero(v: Option<&Value>) -> String { - match v { - Some(Value::String(s)) if !s.is_empty() => s.clone(), - _ => "0".to_string(), - } -} - -/// body 值 ⇒ 文本(`null` / 对象 / 数组 ⇒ `None` ⇒ 写 NULL)。 -fn value_to_text(v: Option<&Value>) -> Option { - match v { - Some(Value::String(s)) => Some(s.clone()), - Some(Value::Number(n)) => Some(n.to_string()), - Some(Value::Bool(b)) => Some(b.to_string()), - _ => None, - } -} - -/// body 里的 `id` ⇒ `Some(id 文本)`(有 id)/ `None`(无 id)。 -/// -/// 🔴 键存在且非 null、但**不是字符串**(如数字 `123`)⇒ **也算「有 id」**—— -/// react 的 `if (dto.id)` 对数字是 truthy ⇒ 走更新分支;按其 JSON 文本去查, -/// 查不到 ⇒ `400 '用户不存在'`(**不是**新建一行)。 -/// 空串 ⇒ 视作**无 id**(react 的 `if ('')` 是 falsy)。 -fn body_id(obj: &Map) -> Option { - match obj.get("id") { - None | Some(Value::Null) => None, - Some(Value::String(s)) if s.is_empty() => None, - Some(Value::String(s)) => Some(s.clone()), - Some(other) => Some(other.to_string()), - } -} - -/// body 里取一个整数(`null` / 不可解析 ⇒ `None`)。 -fn value_to_i64(v: Option<&Value>) -> Option { - match v { - Some(Value::Number(n)) => n.as_i64().or_else(|| n.as_f64().map(|f| f as i64)), - Some(Value::String(s)) => s.trim().parse::().ok(), - _ => None, - } -} - -/// 绑定参数数组 ⇒ `&[&(dyn ToSql + Sync)]`(值一律按 text 传,类型转换交给 SQL 里的 CAST)。 -/// -/// 🔴 `Option: ToSql` ⇒ `None` 会被编码成 SQL `NULL`(不是空串)。 -fn params_of(values: &[Option]) -> Vec<&(dyn ToSql + Sync)> { - values.iter().map(|v| v as &(dyn ToSql + Sync)).collect() -} - -/// 一条待写入的字段。 -struct Field { - /// 目标列(**内部常量**,拼进 SQL 前仍要过白名单)。 - column: &'static str, - /// 追加在 `::text` 之后的类型转换(`""` / `"::integer"` / `"::bigint"`)。 - cast: &'static str, - /// 值(`None` ⇒ NULL)。 - value: Option, -} - -/// 构造 `UPDATE
SET ... WHERE f_id = $n::text`。 -/// -/// 🔴 表名 / 列名都过白名单(红线 R1.10);**值全部走绑定参数**。 -fn build_update( - table: &str, - id: &str, - fields: &[Field], -) -> Result<(String, Vec>), pglite::Error> { - let table = db::valid_table(table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; - let mut values: Vec> = Vec::new(); - let mut assigns: Vec = Vec::new(); - for f in fields { - // 🔴 白名单不过 ⇒ **不拼进 SQL**(宁可少更新一列,也不让用户 body 里的键进 SQL 文本)。 - let Some(col) = db::valid_column(f.column) else { - continue; - }; - values.push(f.value.clone()); - assigns.push(format!("{} = ${}::text{}", col, values.len(), f.cast)); - } - if assigns.is_empty() { - return Err(pglite::Error::Protocol("没有可更新的字段".to_string())); - } - values.push(Some(id.to_string())); - let sql = format!( - "UPDATE {} SET {} WHERE f_id = ${}::text", - table, - assigns.join(", "), - values.len() - ); - Ok((sql, values)) -} - -/// 按 id 读回一行(`None` ⇒ 没有这行)。 -async fn fetch_by_id( - db: &Db, - table: &str, - columns: &str, - id: &str, -) -> Result, pglite::Error> { - let table = db::valid_table(table) - .ok_or_else(|| pglite::Error::Protocol(format!("非法表名: {table}")))?; - let sql = format!("SELECT {columns} FROM {table} WHERE f_id = $1::text LIMIT 1"); - let rows = db.query_json_params(&sql, &[&id]).await?; - Ok(rows.into_iter().next()) -} - -/// 用户的 `roleIds` / `roleNames`(一次性把关系表与角色表各查一遍,避免 N+1)。 -/// -/// 🔴 `base_role_relation` **不过滤 `f_delete_mark`**(照抄 react 的 `roleRelRepo.find`)。 -/// 🔴 `roleNames` 查不到就**跳过**(不是空串、不是 null)⇒ 长度可能小于 `roleIds`。 -async fn user_role_map( - db: &Db, -) -> Result, Vec)>, pglite::Error> { - let rels = db - .query_json( - "SELECT f_object_id AS \"objectId\", f_role_id AS \"roleId\" \ - FROM base_role_relation WHERE f_object_type = 'user'", - ) - .await?; - let roles = db - .query_json( - "SELECT f_id AS \"id\", f_full_name AS \"fullName\" FROM base_role \ - WHERE f_delete_mark = 0", - ) - .await?; - let mut names: HashMap = HashMap::new(); - for r in &roles { - let (Some(id), Some(name)) = ( - r.get("id").and_then(Value::as_str), - r.get("fullName").and_then(Value::as_str), - ) else { - continue; - }; - names.insert(id.to_string(), name.to_string()); - } - - let mut map: HashMap, Vec)> = HashMap::new(); - for rel in &rels { - let (Some(object_id), Some(role_id)) = ( - rel.get("objectId").and_then(Value::as_str), - rel.get("roleId").and_then(Value::as_str), - ) else { - continue; - }; - let entry = map.entry(object_id.to_string()).or_default(); - entry.0.push(role_id.to_string()); - } - // `roleNames` 按 `roleIds` 的顺序取,查不到就跳过。 - for (role_ids, role_names) in map.values_mut() { - for rid in role_ids.iter() { - if let Some(name) = names.get(rid) { - role_names.push(name.clone()); - } - } - } - Ok(map) -} - -// ---------------------------------------------------------------- User - -/// `GET /api/ssw/sys/User/List`(契约 §6.2 / §7.1)。 -pub async fn user_list(State(state): State, headers: HeaderMap) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {USER_COLUMNS} FROM base_user WHERE f_delete_mark = 0 \ - ORDER BY f_creator_time DESC" - ); - let rows = match state.db.query_json(&sql).await { - Ok(rows) => rows, - Err(e) => return db_error(e, "用户列表查询"), - }; - let role_map = match user_role_map(&state.db).await { - Ok(m) => m, - Err(e) => return db_error(e, "用户角色关系查询"), - }; - - let mut out: Vec = Vec::with_capacity(rows.len()); - for row in rows { - let Some(obj) = row.as_object() else { - continue; - }; - let id = obj.get("id").and_then(Value::as_str).unwrap_or_default(); - let (role_ids, role_names) = role_map.get(id).cloned().unwrap_or_default(); - let mut item = obj.clone(); - // 🔴 响应里**没有 `password` 键**(投影里根本没选 `f_password`)。 - item.insert("roleIds".to_string(), json!(role_ids)); - item.insert("roleNames".to_string(), json!(role_names)); - out.push(Value::Object(item)); - } - ok(Value::Array(out)) -} - -/// `POST /api/ssw/sys/User/Save`(契约 §7.1)。 -pub async fn user_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - - // ---- 1) 账号必填 ---- - let account = obj.get("account").and_then(Value::as_str).unwrap_or(""); - if account.is_empty() { - return fail(400, "账号不能为空"); - } - let account = account.to_string(); - - // ---- 2) 查重(新建 / 更新**都查**):只比 `f_delete_mark = 0` 的行 ---- - // 🔴 官方 DDL 对 `f_account` **无 UNIQUE** ⇒ 唯一性只在应用层。 - let dup = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_user \ - WHERE f_account = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&account], - ) - .await - { - Ok(rows) => rows - .first() - .and_then(|r| r.get("id")) - .and_then(Value::as_str) - .map(str::to_string), - Err(e) => return db_error(e, "用户查重"), - }; - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - if dup.is_some() { - return fail(400, format!("账号已存在:{account}")); - } - let new_id = new_uuid(); - let real_name = value_to_text(obj.get("realName")); - // 🔴 body 没有 password ⇒ `md5('123456')`(react 的默认口令)。 - let password = match obj.get("password").and_then(Value::as_str) { - Some(p) if !p.is_empty() => md5_hex(p), - _ => md5_hex("123456"), - }; - let is_admin = if truthy(obj.get("isAdministrator")) { - "1" - } else { - "0" - }; - let organize_id = or_zero(obj.get("organizeId")); - let now = now_str(); - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(account.clone()), - real_name, - Some(password), - Some(is_admin.to_string()), - Some(organize_id), - Some("admin".to_string()), - Some(now), - Some("1".to_string()), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_user \ - (f_id, f_tenant_id, f_account, f_real_name, f_password, f_is_administrator, \ - f_organize_id, f_creator_user_id, f_creator_time, f_enabled_mark, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ - $7::text, $8::text, $9::text::timestamp, $10::text::integer, \ - $11::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建用户"); - } - if let Err(e) = write_user_roles(&state, &new_id, &obj).await { - return db_error(e, "用户角色关联写入"); - } - user_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(user_id) => { - // 🔴 按 `f_id` 查,**不按 `f_delete_mark` 过滤** ⇒ 软删过的行也算存在。 - let exists = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, &user_id).await { - Ok(v) => v.is_some(), - Err(e) => return db_error(e, "用户查询"), - }; - if !exists { - return fail(400, "用户不存在"); - } - // 🔴 dup 存在**且**不是自己 ⇒ 账号已被占用。 - if let Some(dup_id) = &dup { - if dup_id != &user_id { - return fail(400, format!("账号已存在:{account}")); - } - } - - let mut fields: Vec = Vec::new(); - // `f_account` 必覆盖(body 里 account 必填)。 - fields.push(Field { - column: "f_account", - cast: "", - value: Some(account.clone()), - }); - // `f_real_name`:**body 有才覆盖**(裁决 S16)。 - if obj.contains_key("realName") { - fields.push(Field { - column: "f_real_name", - cast: "", - value: value_to_text(obj.get("realName")), - }); - } - // `f_is_administrator`:**总是**覆盖为 body 真值 ? 1 : 0。 - fields.push(Field { - column: "f_is_administrator", - cast: "::integer", - value: Some( - if truthy(obj.get("isAdministrator")) { - "1" - } else { - "0" - } - .to_string(), - ), - }); - // `f_organize_id`:**总是**覆盖为 `body.organizeId || '0'`。 - fields.push(Field { - column: "f_organize_id", - cast: "", - value: Some(or_zero(obj.get("organizeId"))), - }); - // `f_password`:**body.password 非空才**覆盖。 - if let Some(p) = obj.get("password").and_then(Value::as_str) { - if !p.is_empty() { - fields.push(Field { - column: "f_password", - cast: "", - value: Some(md5_hex(p)), - }); - } - } - // ⚠️ 更新**不**碰 `f_creator_time` / `f_enabled_mark` / `f_delete_mark`。 - let (sql, values) = match build_update("base_user", &user_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造用户更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新用户"); - } - if let Err(e) = write_user_roles(&state, &user_id, &obj).await { - return db_error(e, "用户角色关联写入"); - } - user_payload(&state, &user_id).await - } - } -} - -/// `DELETE /api/ssw/sys/User/Delete?id=`(契约 §7.1)。 -/// -/// 🔴 **不检查用户是否存在** ⇒ 不存在也返回成功(幂等)。 -pub async fn user_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, USER_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删用户 + 硬删角色关联 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 - let sql = "WITH d AS (UPDATE base_user SET f_delete_mark = 1 WHERE f_id = $1::text) \ - DELETE FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除用户"); - } - ok(Value::Null) -} - -/// 写用户的角色关联:`roleIds` 是数组 ⇒ **先硬删旧行再插新行**(契约 §7.1 第 5 条)。 -/// -/// 🔴 `roleIds` **不是数组**(缺省 / 类型不对)⇒ **不动**已有关系(react 的 -/// `Array.isArray(dto.roleIds)` 判定)。 -/// -/// 🔴 **DB 错误必须往上抛**(不吞)—— 吞掉的话角色授权根本没生效,响应却还是 -/// `code=200 / 成功` ⇒ 调用方拿到的信封与库里的事实不符。 -async fn write_user_roles( - state: &AppState, - user_id: &str, - obj: &Map, -) -> Result<(), pglite::Error> { - let Some(Value::Array(items)) = obj.get("roleIds") else { - return Ok(()); - }; - let role_ids: Vec = items - .iter() - .filter_map(|v| v.as_str()) - .filter(|s| !s.is_empty()) - .map(str::to_string) - .collect(); - - // 🔴 原始数组非空、但过滤后一个合法 id 都没有 ⇒ 这是**非法输入**, - // 不是「清空角色」。⇒ **不动**已有关系行(不要硬删)。 - if !items.is_empty() && role_ids.is_empty() { - return Ok(()); - } - - let mut values: Vec> = vec![Some(user_id.to_string())]; - let sql = if role_ids.is_empty() { - // 空数组 ⇒ 只删不插。 - "DELETE FROM base_role_relation WHERE f_object_type = 'user' AND f_object_id = $1::text" - .to_string() - } else { - let mut rows: Vec = Vec::new(); - for rid in &role_ids { - values.push(Some(new_uuid())); - values.push(Some(rid.clone())); - rows.push(format!( - "(${}::text, ${}::text)", - values.len() - 1, - values.len() - )); - } - // 硬删旧行 + 插新行 ⇒ **一条语句**(data-modifying CTE)⇒ 原子(裁决 P59)。 - format!( - "WITH d AS (DELETE FROM base_role_relation \ - WHERE f_object_type = 'user' AND f_object_id = $1::text) \ - INSERT INTO base_role_relation \ - (f_id, f_tenant_id, f_object_type, f_object_id, f_role_id, f_sort_code, f_delete_mark) \ - SELECT v.f_id, '0', 'user', $1::text, v.f_role_id, 0, 0 \ - FROM (VALUES {}) AS v(f_id, f_role_id)", - rows.join(", ") - ) - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return Err(e); - } - Ok(()) -} - -/// 用户 Save 的响应体 = 落库后该用户行(**去掉 password**)+ `roleIds` + `roleNames`。 -async fn user_payload(state: &AppState, user_id: &str) -> Json { - let row = match fetch_by_id(&state.db, "base_user", USER_COLUMNS, user_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "读回用户"), - }; - let Some(mut obj) = row.and_then(|r| r.as_object().cloned()) else { - return fail(400, "用户不存在"); - }; - let role_map = match user_role_map(&state.db).await { - Ok(m) => m, - Err(e) => return db_error(e, "用户角色关系查询"), - }; - let (role_ids, role_names) = role_map.get(user_id).cloned().unwrap_or_default(); - obj.insert("roleIds".to_string(), json!(role_ids)); - obj.insert("roleNames".to_string(), json!(role_names)); - ok(Value::Object(obj)) -} - -// ---------------------------------------------------------------- Role - -/// `GET /api/ssw/sys/Role/List`(契约 §7.2)。 -pub async fn role_list(State(state): State, headers: HeaderMap) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {ROLE_COLUMNS} FROM base_role WHERE f_delete_mark = 0 ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "角色列表查询"), - } -} - -/// `POST /api/ssw/sys/Role/Save`(契约 §7.2)。 -pub async fn role_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "角色名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - // 先查重 `f_en_code`(只比未软删的行)。 - let en_code = value_to_text(obj.get("enCode")); - if let Some(code) = &en_code { - let dup = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_role \ - WHERE f_en_code = $1::text AND f_delete_mark = 0 LIMIT 1", - &[code], - ) - .await - { - Ok(rows) => rows.first().is_some(), - Err(e) => return db_error(e, "角色查重"), - }; - if dup { - return fail(400, format!("角色编码已存在:{code}")); - } - } - let new_id = new_uuid(); - // `f_type` = `body.type ?? 'user'`。 - let role_type = match obj.get("type") { - Some(Value::Null) | None => "user".to_string(), - Some(v) => value_to_text(Some(v)).unwrap_or_else(|| "user".to_string()), - }; - let description = value_to_text(obj.get("description")); - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - en_code, - Some(role_type), - description, - Some("1".to_string()), - Some(sort_code.to_string()), - Some("admin".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_role \ - (f_id, f_tenant_id, f_full_name, f_en_code, f_type, f_description, \ - f_enabled_mark, f_sort_code, f_creator_user_id, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text, \ - $7::text::integer, $8::text::bigint, $9::text, $10::text::timestamp, \ - $11::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建角色"); - } - role_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(role_id) => { - // 🔴 按 `f_id` 查,**不带 `f_delete_mark` 过滤**。 - let existing = match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, &role_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "角色查询"), - }; - let Some(existing) = existing else { - return fail(400, "角色不存在"); - }; - // ⚠️ 更新**不做** `f_en_code` 查重;**不碰** `f_sort_code` / `f_enabled_mark`。 - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - if obj.contains_key("enCode") { - fields.push(Field { - column: "f_en_code", - cast: "", - value: value_to_text(obj.get("enCode")), - }); - } - // `f_type` = `body.type ?? 原值`。 - fields.push(Field { - column: "f_type", - cast: "", - value: match obj.get("type") { - Some(Value::Null) | None => existing - .get("type") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - if obj.contains_key("description") { - fields.push(Field { - column: "f_description", - cast: "", - value: value_to_text(obj.get("description")), - }); - } - let (sql, values) = match build_update("base_role", &role_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造角色更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新角色"); - } - role_payload(&state, &role_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Role/Delete?id=`(契约 §7.2)。 -pub async fn role_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ROLE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删角色 + 软删该角色的授权 + 硬删该角色的关系 ⇒ **一条语句**(原子)。 - let sql = "WITH a AS (UPDATE base_role SET f_delete_mark = 1 WHERE f_id = $1::text), \ - b AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_object_id = $1::text), \ - c AS (DELETE FROM base_role_relation WHERE f_role_id = $1::text) \ - SELECT 1"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除角色"); - } - ok(Value::Null) -} - -/// `GET /api/ssw/sys/Role/Modules?roleId=`(契约 §7.2)—— **仅登录**。 -pub async fn role_modules( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_login(&state, &headers).await { - return resp; - } - let role_id = query_param(&raw, "roleId"); - match role_module_ids(&state.db, &role_id).await { - Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), - Err(e) => db_error(e, "角色菜单查询"), - } -} - -/// 角色的菜单 id 列表(契约 §7.2 / §7.5 —— 两处同一份语义)。 -async fn role_module_ids(db: &Db, role_id: &str) -> Result, pglite::Error> { - let rows = db - .query_json_params( - "SELECT f_item_id AS \"itemId\" FROM base_authorize \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text AND f_delete_mark = 0", - &[&role_id], - ) - .await?; - Ok(rows - .iter() - .filter_map(|r| r.get("itemId").and_then(Value::as_str)) - .map(str::to_string) - .collect()) -} - -/// 角色 Save 的响应体 = 落库后该角色行。 -async fn role_payload(state: &AppState, role_id: &str) -> Json { - match fetch_by_id(&state.db, "base_role", ROLE_COLUMNS, role_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "角色不存在"), - Err(e) => db_error(e, "读回角色"), - } -} - -// ---------------------------------------------------------------- Organize - -/// `GET /api/ssw/sys/Organize/List`(契约 §7.3)。 -pub async fn organize_list( - State(state): State, - headers: HeaderMap, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {ORGANIZE_COLUMNS} FROM base_organize WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "机构列表查询"), - } -} - -/// `POST /api/ssw/sys/Organize/Save`(契约 §7.3)。 -pub async fn organize_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "机构名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - let new_id = new_uuid(); - let parent_id = or_zero(obj.get("parentId")); - // `f_category` = `body.category ?? NULL`。 - let category = match obj.get("category") { - Some(Value::Null) | None => None, - Some(v) => value_to_text(Some(v)), - }; - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_organize` entity 没有该列)。 - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - Some(parent_id), - category, - Some(sort_code.to_string()), - Some("1".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_organize \ - (f_id, f_tenant_id, f_full_name, f_parent_id, f_category, f_sort_code, \ - f_enabled_mark, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::bigint, \ - $7::text::integer, $8::text::timestamp, $9::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建机构"); - } - organize_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(org_id) => { - let existing = - match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, &org_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "机构查询"), - }; - let Some(existing) = existing else { - return fail(400, "机构不存在"); - }; - // ⚠️ 更新**不碰** `f_sort_code` / `f_enabled_mark`。 - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - fields.push(Field { - column: "f_parent_id", - cast: "", - value: Some(or_zero(obj.get("parentId"))), - }); - // `f_category` = `body.category ?? 原值`。 - fields.push(Field { - column: "f_category", - cast: "", - value: match obj.get("category") { - Some(Value::Null) | None => existing - .get("category") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - let (sql, values) = match build_update("base_organize", &org_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造机构更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新机构"); - } - organize_payload(&state, &org_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Organize/Delete?id=`(契约 §7.3)。 -pub async fn organize_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, ORGANIZE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 先查子机构:有 ⇒ 拒删。 - let children = match state - .db - .query_json_params( - "SELECT f_id AS \"id\" FROM base_organize \ - WHERE f_parent_id = $1::text AND f_delete_mark = 0 LIMIT 1", - &[&id], - ) - .await - { - Ok(rows) => rows, - Err(e) => return db_error(e, "子机构查询"), - }; - if !children.is_empty() { - return fail(400, "该机构下还有子机构,先删除子机构"); - } - let sql = "UPDATE base_organize SET f_delete_mark = 1 WHERE f_id = $1::text"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除机构"); - } - ok(Value::Null) -} - -/// 机构 Save 的响应体 = 落库后该机构行。 -async fn organize_payload(state: &AppState, org_id: &str) -> Json { - match fetch_by_id(&state.db, "base_organize", ORGANIZE_COLUMNS, org_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "机构不存在"), - Err(e) => db_error(e, "读回机构"), - } -} - -// ---------------------------------------------------------------- Module - -/// `GET /api/ssw/sys/Module/List`(契约 §7.4)。 -pub async fn module_list( - State(state): State, - headers: HeaderMap, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let sql = format!( - "SELECT {MODULE_COLUMNS} FROM base_module WHERE f_delete_mark = 0 \ - ORDER BY f_sort_code ASC" - ); - match state.db.query_json(&sql).await { - Ok(rows) => ok(Value::Array(rows)), - Err(e) => db_error(e, "菜单列表查询"), - } -} - -/// `POST /api/ssw/sys/Module/Save`(契约 §7.4)。 -pub async fn module_save( - State(state): State, - headers: HeaderMap, - body: Bytes, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let full_name = obj.get("fullName").and_then(Value::as_str).unwrap_or(""); - if full_name.is_empty() { - return fail(400, "菜单名称不能为空"); - } - let full_name = full_name.to_string(); - - let id = body_id(&obj); - - match id { - // ---- 新建 ---- - None => { - let new_id = new_uuid(); - let url_address = value_to_text(obj.get("urlAddress")); - let parent_id = or_zero(obj.get("parentId")); - // 🔴 `f_type` 是 **INTEGER**(1=目录 / 2=页面),缺省 **2**。 - let module_type = value_to_i64(obj.get("type")).unwrap_or(2); - // `f_category` 是 **VARCHAR 分类**,缺省 NULL。 - let category = match obj.get("category") { - Some(Value::Null) | None => None, - Some(v) => value_to_text(Some(v)), - }; - let icon = value_to_text(obj.get("icon")); - let sort_code = value_to_i64(obj.get("sortCode")).unwrap_or(0); - let now = now_str(); - // ⚠️ **不写 `f_creator_user_id`**(react 的 `base_module` entity 没有该列)。 - let values: Vec> = vec![ - Some(new_id.clone()), - Some("0".to_string()), - Some(full_name), - url_address, - Some(parent_id), - Some(module_type.to_string()), - category, - icon, - Some(sort_code.to_string()), - Some("1".to_string()), - Some(now), - Some("0".to_string()), - ]; - let sql = "INSERT INTO base_module \ - (f_id, f_tenant_id, f_full_name, f_url_address, f_parent_id, f_type, \ - f_category, f_icon, f_sort_code, f_enabled_mark, f_creator_time, f_delete_mark) \ - VALUES ($1::text, $2::text, $3::text, $4::text, $5::text, $6::text::integer, \ - $7::text, $8::text, $9::text::bigint, $10::text::integer, \ - $11::text::timestamp, $12::text::integer)"; - if let Err(e) = state.db.exec_params(sql, ¶ms_of(&values)).await { - return db_error(e, "新建菜单"); - } - module_payload(&state, &new_id).await - } - // ---- 更新 ---- - Some(module_id) => { - let existing = - match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, &module_id).await { - Ok(v) => v, - Err(e) => return db_error(e, "菜单查询"), - }; - let Some(existing) = existing else { - return fail(400, "菜单不存在"); - }; - let mut fields: Vec = Vec::new(); - fields.push(Field { - column: "f_full_name", - cast: "", - value: Some(full_name), - }); - // 🔴 `f_url_address` **body 没这个键 ⇒ 不动原值** —— - // 它是权限守卫的比对键,被清成 NULL 会造成「静默越权」(裁决 S16)。 - if obj.contains_key("urlAddress") { - fields.push(Field { - column: "f_url_address", - cast: "", - value: value_to_text(obj.get("urlAddress")), - }); - } - fields.push(Field { - column: "f_parent_id", - cast: "", - value: Some(or_zero(obj.get("parentId"))), - }); - // `f_type` = `body.type ?? 原值`。 - let orig_type = existing.get("type").and_then(Value::as_i64); - let new_type = match obj.get("type") { - Some(Value::Null) | None => orig_type, - Some(v) => value_to_i64(Some(v)).or(orig_type), - }; - fields.push(Field { - column: "f_type", - cast: "::integer", - value: new_type.map(|v| v.to_string()), - }); - // `f_category` = `body.category ?? 原值`。 - fields.push(Field { - column: "f_category", - cast: "", - value: match obj.get("category") { - Some(Value::Null) | None => existing - .get("category") - .and_then(Value::as_str) - .map(str::to_string), - Some(v) => value_to_text(Some(v)), - }, - }); - // `f_icon`:**body 没这个键 ⇒ 不动原值**。 - if obj.contains_key("icon") { - fields.push(Field { - column: "f_icon", - cast: "", - value: value_to_text(obj.get("icon")), - }); - } - // `f_sort_code` = `body.sortCode ?? 0`(⚠️ 缺省 ⇒ **0**,不是原值)。 - fields.push(Field { - column: "f_sort_code", - cast: "::bigint", - value: Some(value_to_i64(obj.get("sortCode")).unwrap_or(0).to_string()), - }); - let (sql, values) = match build_update("base_module", &module_id, &fields) { - Ok(v) => v, - Err(e) => return db_error(e, "构造菜单更新语句"), - }; - if let Err(e) = state.db.exec_params(&sql, ¶ms_of(&values)).await { - return db_error(e, "更新菜单"); - } - module_payload(&state, &module_id).await - } - } -} - -/// `DELETE /api/ssw/sys/Module/Delete?id=`(契约 §7.4)。 -pub async fn module_delete( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_module(&state, &headers, MODULE_MODULE).await { - return resp; - } - let id = query_param(&raw, "id"); - // 软删菜单 + 软删该菜单的授权 ⇒ **一条语句**(原子)。 - let sql = "WITH a AS (UPDATE base_module SET f_delete_mark = 1 WHERE f_id = $1::text), \ - b AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_item_type = 'module' AND f_item_id = $1::text) \ - SELECT 1"; - if let Err(e) = state.db.exec_params(sql, &[&id]).await { - return db_error(e, "删除菜单"); - } - ok(Value::Null) -} - -/// 菜单 Save 的响应体 = 落库后该菜单行。 -async fn module_payload(state: &AppState, module_id: &str) -> Json { - match fetch_by_id(&state.db, "base_module", MODULE_COLUMNS, module_id).await { - Ok(Some(row)) => ok(row), - Ok(None) => fail(400, "菜单不存在"), - Err(e) => db_error(e, "读回菜单"), - } -} - -// ---------------------------------------------------------------- 授权 - -/// `PUT /api/permission/Authority/Data/{objectId}`(契约 §7.5)—— **仅登录**。 -/// -/// 🔴 **body 里的 `objectType` 被完全忽略**(react 只读 `body.module`) -/// ⇒ 落库一律 `f_object_type='role'`、`f_item_type='module'`、`f_object_id=`。 -/// **不要**因为 body 传了 `'Role'` 就拒绝(裁决:react 不校验,本仓也不校验)。 -/// -/// 🔴 **面 B 分流**:未登录时面 A 返 `600`、面 B 返 `602` -/// (官方前端只对 `601`/`602` 清 token ⇒ 返 `600` 会卡住不跳登录)。 -pub async fn authority_data( - State(state): State, - headers: HeaderMap, - Path(object_id): Path, - body: Bytes, -) -> Json { - if let Err(resp) = require_login_any(&state, &headers).await { - return resp; - } - let obj = match body_object(&body) { - Ok(o) => o, - Err(resp) => return resp, - }; - let module_ids = normalize_module(obj.get("module")); - if let Err(e) = write_role_modules(&state.db, &object_id, &module_ids).await { - return db_error(e, "写授权"); - } - ok(Value::Null) -} - -/// `GET /api/permission/Authority/RoleModules?roleId=`(契约 §7.5)—— **仅登录**。 -pub async fn authority_role_modules( - State(state): State, - headers: HeaderMap, - raw: RawQuery, -) -> Json { - if let Err(resp) = require_login(&state, &headers).await { - return resp; - } - let role_id = query_param(&raw, "roleId"); - match role_module_ids(&state.db, &role_id).await { - Ok(ids) => ok(Value::Array(ids.into_iter().map(Value::String).collect())), - Err(e) => db_error(e, "角色菜单查询"), - } -} - -/// 归一化 `module`(react 的 `normalizeModule`)。 -/// -/// - **不是数组**(缺省 / 类型不对)⇒ `[]`; -/// - `module[0]` 是数组 ⇒ **展平一层**(兼容官方前端的 `[checked, halfChecked]` 二维形态); -/// - 只保留**非空字符串**。 -fn normalize_module(raw: Option<&Value>) -> Vec { - let Some(Value::Array(items)) = raw else { - return Vec::new(); - }; - let flatten = matches!(items.first(), Some(Value::Array(_))); - let mut out: Vec = Vec::new(); - for item in items { - if flatten { - match item { - Value::Array(inner) => { - for x in inner { - if let Some(s) = x.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - } - other => { - if let Some(s) = other.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - } - } else if let Some(s) = item.as_str() { - if !s.is_empty() { - out.push(s.to_string()); - } - } - } - out -} - -/// 写「角色 → 菜单」授权:先软删旧行,再插新行。 -/// -/// 🔴 **一条语句**(data-modifying CTE)⇒ 软删 + 插入原子(裁决 P59)。 -/// ⚠️ 空数组 ⇒ **只软删不插**。 -async fn write_role_modules( - db: &Db, - object_id: &str, - module_ids: &[String], -) -> Result<(), pglite::Error> { - if module_ids.is_empty() { - let sql = "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text) \ - SELECT 1"; - db.exec_params(sql, &[&object_id]).await?; - return Ok(()); - } - let mut values: Vec> = vec![Some(object_id.to_string())]; - let mut rows: Vec = Vec::new(); - for module_id in module_ids { - values.push(Some(new_uuid())); - values.push(Some(module_id.clone())); - rows.push(format!( - "(${}::text, ${}::text)", - values.len() - 1, - values.len() - )); - } - let sql = format!( - "WITH d AS (UPDATE base_authorize SET f_delete_mark = 1 \ - WHERE f_object_type = 'role' AND f_item_type = 'module' \ - AND f_object_id = $1::text) \ - INSERT INTO base_authorize \ - (f_id, f_tenant_id, f_object_type, f_object_id, f_item_id, f_item_type, \ - f_sort_code, f_delete_mark) \ - SELECT v.f_id, '0', 'role', $1::text, v.f_item_id, 'module', 0, 0 \ - FROM (VALUES {}) AS v(f_id, f_item_id)", - rows.join(", ") - ); - db.exec_params(&sql, ¶ms_of(&values)).await?; - Ok(()) -} +pub use sspf_core::sys::*; diff --git a/src/backend/src/platform/variate_catalog.rs b/src/backend/src/platform/variate_catalog.rs index bf7a3f8..7284b37 100644 --- a/src/backend/src/platform/variate_catalog.rs +++ b/src/backend/src/platform/variate_catalog.rs @@ -1,476 +1,5 @@ -//! 公式编辑器的**函数目录**与**系统变量目录**。 -//! -//! 🔴 **本文件是生成物,不许手改** —— 由 `scripts/gen-function-catalog.py` -//! 从官方 Java 枚举逐条转出: -//! `jnpf-system-entity/.../model/variate/{FunctionTypeEnum,SystemVariateEnum}.java` -//! 改了官方枚举就重跑脚本;`gen-function-catalog.py --check` 是闸门。 -//! -//! 为什么值得生成:这 100+ 条是**前端公式编辑器的下拉与帮助文本**(含 HTML), -//! 手抄漏一条不会有任何编译/测试报错,只会让某个函数在帮助里点不开。 +//! variate_catalog —— **转发壳**:真源在 [`sspf_core::variate_catalog`](M2 平台核心下沉)。 +//! 🔴 只做转发、不含实现;别往壳里塞东西(`check-arch.sh` AR9/AR10 会红)。 +//! 为什么留壳、闸门怎么改:见 `docs/CRATES-MIGRATION.md` §4 M2。 -/// 一条公式函数。 -pub struct FuncEntry { - /// 函数名(`SUM` / `ROUND` …),也是表达式里的写法。 - pub name: &'static str, - /// 帮助文本(**HTML 片段**,前端直接 v-html 渲染)。 - pub description: &'static str, - /// 分类枚举名(`MATH` / `TIME` …)。 - pub category: &'static str, - /// 分类中文名(`数学函数` …)—— 与 `category` 一一对应,冗余存一份。 - pub sub_category: &'static str, -} - -/// 一条系统变量(`@userId` 之类,公式里可直接引用)。 -pub struct VariateEntry { - /// 变量名(含 `@` 前缀)。 - pub field: &'static str, - /// 中文说明。 - pub description: &'static str, -} - -/// 函数分类(官方 `FunctionCategory` 全量,**含** `ALL`)。 -pub const FUNCTION_CATEGORIES: &[(&str, &str)] = &[ - (r#"ALL"#, r#"全部函数"#), - (r#"ENCRYPTION"#, r#"加解密函数"#), - (r#"MASKING"#, r#"脱敏函数"#), - (r#"OBJECT"#, r#"对象函数"#), - (r#"MATH"#, r#"数学函数"#), - (r#"COMMON"#, r#"常用函数"#), - (r#"TIME"#, r#"时间函数"#), - (r#"CONVERSION"#, r#"转换函数"#), - (r#"COLLECTION"#, r#"集合函数"#), - (r#"TEXT"#, r#"文本函数"#), - (r#"LOGIC"#, r#"逻辑函数"#), -]; - -/// 公式函数目录(35 条,官方 `FunctionTypeEnum` 逐条)。 -pub const FUNCTIONS: &[FuncEntry] = &[ - FuncEntry { - name: r#"SUM"#, - description: r#"
    -
  • SUM函数可以获取一组数值的总和
  • -
  • 用法:SUM(数值1,数值2,...)
  • -
  • 示例:SUM(语文成绩,数学成绩)返回两门课程总分
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"MAX"#, - description: r#"
    -
  • MAX函数可以获取一组数值的最大值
  • -
  • 用法:MAX(数字1,数字2,...)
  • -
  • 示例:MAX(语文成绩,数学成绩,英语成绩)返回三门课程中的最高分
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"MIN"#, - description: r#"
    -
  • MIN函数可以获取一组数值的最小值
  • -
  • 用法:MIN(数字1,数字2,...)
  • -
  • 示例:MIN(语文成绩,数学成绩,英语成绩)返回三门课程中的最低分
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"PRODUCT"#, - description: r#"
    -
  • PRODUCT函数可以获取一组数值的乘积
  • -
  • 用法:PRODUCT(数值1,数值2,...)
  • -
  • 示例:PRODUCT(单价,数量)获取总价,即单价和数量的乘积
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"ROUND"#, - description: r#"
    -
  • ROUND函数可以将数字四舍五入到指定的位数
  • -
  • 用法:ROUNDROUND(数字,数字位数)
  • -
  • 示例:ROUNDROUND(3.1485,2)返回3.15
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"COUNT"#, - description: r#"
    -
  • COUNT函数可以获取参数的数量
  • -
  • 用法:COUNT(值,值,...)
  • -
  • 示例:COUNT(小王,小李)返回2,即人员数量
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"DIVIDE"#, - description: r#"
    -
  • DIVIDE函数可以返回数值相除
  • -
  • 用法:DIVIDE(被除数,除数)
  • -
  • 示例:DIVIDE(总价,单价)获取数量,即总价除单价
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"SUBTRACT"#, - description: r#"
    -
  • SUBTRACT函数可以返回数值相减
  • -
  • 用法:SUBTRACT(被减数,减数)
  • -
  • 示例:SUBTRACT(总收入,总支出)返回收支总利润
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"MOD"#, - description: r#"
    -
  • MOD函数可以获取两数相除的余数
  • -
  • 用法:MOD(被除数,除数)
  • -
  • 示例:MOD(4,3)返回1,也就是4/3的余数
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"ABS"#, - description: r#"
    -
  • ABS函数可以获取一个数的绝对值
  • -
  • 用法:ABS(数字)
  • -
  • 示例:ABS(-8)可以返回8,也就是-8的绝对值
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"INT"#, - description: r#"
    -
  • INT函数可以获取一个数的整数部分
  • -
  • 用法:INT(数字)
  • -
  • 示例:INT(3.1415)返回3,也就是3.1415的整数部分
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"POWER"#, - description: r#"
    -
  • POWER函数可以获取数字乘幂的结果
  • -
  • 用法:POWER(数字,指数)
  • -
  • 示例:POWER(3,2)返回9,也就是3的2次方
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"FIXED"#, - description: r#"
    -
  • FIXED函数可将数字舍入到指定的小数位数并输出为文本
  • -
  • 用法:FIXED(数字,小数位数)
  • -
  • 示例:FIXED(3.1415,2)返回"3.14"
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"SQRT"#, - description: r#"
    -
  • SQRT函数可以获取一个数字的正平方根
  • -
  • 用法:SQRT(数字)
  • -
  • 示例:SQRT(9)返回3,也就是9的正平方根
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"LARGE"#, - description: r#"
    -
  • LARGE函数可以获取数据集中第k个最大值
  • -
  • 用法:LARGE(数组,k)
  • -
  • 示例:LARGE(学生成绩.数学成绩,1)返回子表单"学生成绩"中排名第1的"数学成绩"
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"SMALL"#, - description: r#"
    -
  • SMALL函数可以返回数据集中第k个最小值
  • -
  • 用法:SMALL(数组,k)
  • -
  • 示例:SMALL(学生成绩.数学成绩, 1)返回子表单"学生成绩"中排名倒数第一的"数学成绩"
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"AVERAGE"#, - description: r#"
    -
  • AVERAGE函数可以获取一组数值的算术平均值
  • -
  • 用法:AVERAGE(数字1,数字2,...)
  • -
  • 示例:AVERAGE(语文成绩,数学成绩, 英语成绩)返回三门课程的平均分
  • -
"#, - category: r#"MATH"#, - sub_category: r#"数学函数"#, - }, - FuncEntry { - name: r#"SPLIT"#, - description: r#"
    -
  • SPLIT函数可以将文本按指定分割符分割成数组,需配合ARRAYGET来获取指定位置字 -符,ARRAYGET(SPLIT(text,text separator),1)
  • -
  • 用法:SPLIT(文本,分隔符_文本)
  • -
  • 示例:SPLIT("JNPF-快速开发平台","-")返回"JNPF,快速开发平台"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"TEXT"#, - description: r#"
    -
  • TEXT函数可以将数字转化成文本
  • -
  • 用法:TEXT(数字)
  • -
  • 示例:TEXT(3.1415)返回"3.1415"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"TRIM"#, - description: r#"
    -
  • TRIM函数可以删除文本首尾的空格
  • -
  • 用法:TRIM(文本)
  • -
  • 示例:TRIM(" JNPF ")返回"JNPF"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"UUID"#, - description: r#"
    -
  • UUID函数用于随机码生成
  • -
  • 用法:UUID()
  • -
  • 示例:CONCATENATE("JNPF-",UUID())生成JNPF-开头的流水号,比如JNPF-FYJQ03VCOA03KCE20YW45E7OIMC390UJU2MK0
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"VALUE"#, - description: r#"
    -
  • VALUE函数可以将文本转化为数字
  • -
  • 用法:VALUE(文本)
  • -
  • 示例:VALUE("3.1415")返回3.1415
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"SEARCH"#, - description: r#"
    -
  • SEARCH函数可以获取文本1在文本2中的开始位置
  • -
  • 用法:SEARCH(文本1,文本2)
  • -
  • 示例:SEARCH("2026","JNPF2026")返回5
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"RMBFORMAT"#, - description: r#"
    -
  • RMBFORMAT函数可以将数字格式化为人民币格式
  • -
  • 用法:RMBFORMAT(mumher,[type])
  • -
  • 示例:RMBFORMAT(数字输入框)输入123,返回壹佰贰拾参元整
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"REPT"#, - description: r#"
    -
  • REPT函数可以将文本重复一定次数
  • -
  • 用法:REPT(文本,重复次数)
  • -
  • 示例:REPT("JNPF", 3)返回"JNPFJNPFJNPF"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"REPLACE"#, - description: r#"
    -
  • REPLACE函数可以根据指定的字符数,将部分文本替换为不同的文本
  • -
  • 用法:REPLACE(文本,开始位置,替换长度,新文本)
  • -
  • 示例:REPLACE("JNPF快速开发平台",5,10,"数字化平台")返回"JNPF数字化平台
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"PINYINHEADCHAR"#, - description: r#"
    -
  • PINYINHEADCHAR函数可以将字符串中的每个字的首字母以大写形式拼接返回
  • -
  • 用法:PINYINHEADCHAR(文本)
  • -
  • 示例:PINYINHEADCHAR("JNPF快速开发平台") - // 返回"JNPFKSKFPT"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"MID"#, - description: r#"
    -
  • MID函数返回文本中从指定位置开始的指定数目的字符
  • -
  • 用法:MID(文本,开始位置_数字,指定数目)
  • -
  • 示例:MID("JNPF快速开发平台",5,6)返回"快速开发平台"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"UPPER"#, - description: r#"
    -
  • UPPER函数可以将一个文本中的所有小写字母转换为大写字母
  • -
  • 用法:UPPER(文本)
  • -
  • 示例:UPPER("jnpf")返回"JNPF"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"LOWER"#, - description: r#"
    -
  • LOWER函数可以将一个文本中的所有大写字母转换为小写字母
  • -
  • 用法:LOWER(文本)
  • -
  • 示例:LOWER("JNPF")返回"jnpf"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"LEN"#, - description: r#"
    -
  • LEN函数可以获取文本中的字符个数
  • -
  • 用法:LEN(文本)
  • -
  • 示例:LEN("JNPF快速开发平台")返回10,因为这句诗中有10个字符
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"RIGHT"#, - description: r#"
    -
  • RIGHT函数可以获取由给定文本右端指定数量的字符构成的文本值
  • -
  • 用法:RIGHT(文本,文本长度)
  • -
  • 示例:RIGHT("JNPF快速开发平台",4)返回"开发平台",也就是"JNPF快速开发平台"从右往左的前4个字符
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"LEFT"#, - description: r#"
    -
  • LEFT函数可以从一个文本的第一个字符开始返回指定个数的字符
  • -
  • 用法:LEFT(文本,文本长度)
  • -
  • 示例:LEFT("JNPF快速开发平台",4)返回"JNPF",也就是"JNPF快速开发平台"的从左往右的前4个字符
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"CONCATENATE"#, - description: r#"
    -
  • CONCATENATE函数可以将多个文本合并成一个文本
  • -
  • 用法:CONCATENATE(文本1,文本2,...)
  • -
  • 示例:CONCATENATE("JNPF","快速开发平台")会返回"JNPF快速开发平台"
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, - FuncEntry { - name: r#"ARRAYGET"#, - description: r#"
    -
  • ARRAYGET函数用于返回数据集中第k个值
  • -
  • 用法:ARRAYGET(array, k)
  • -
  • 示例:ARRAYGET(SPLIT("JNPF-应用定制工具","-"),1)返回JNPF
  • -
"#, - category: r#"TEXT"#, - sub_category: r#"文本函数"#, - }, -]; - -/// 系统变量目录(18 条,官方 `SystemVariateEnum` 逐条)。 -pub const SYSTEM_VARIATES: &[VariateEntry] = &[ - VariateEntry { - field: r#"@userId"#, - description: r#"当前用户"#, - }, - VariateEntry { - field: r#"@userAndSub"#, - description: r#"当前用户及下属"#, - }, - VariateEntry { - field: r#"@userAndProgeny"#, - description: r#"当前用户及子孙下属"#, - }, - VariateEntry { - field: r#"@organizeId"#, - description: r#"当前用户所属组织"#, - }, - VariateEntry { - field: r#"@organizeAndSub"#, - description: r#"当前用户所属组织及子组织"#, - }, - VariateEntry { - field: r#"@organizeAndProgeny"#, - description: r#"当前用户所属组织及子孙组织"#, - }, - VariateEntry { - field: r#"@positionId"#, - description: r#"当前用户所属岗位"#, - }, - VariateEntry { - field: r#"@positionAndSub"#, - description: r#"当前用户所属岗位及子岗位"#, - }, - VariateEntry { - field: r#"@positionAndProgeny"#, - description: r#"当前用户所属岗位及子孙岗位"#, - }, - VariateEntry { - field: r#"@formId"#, - description: r#"表单ID"#, - }, - VariateEntry { - field: r#"@flowId"#, - description: r#"流程ID"#, - }, - VariateEntry { - field: r#"@taskId"#, - description: r#"任务ID"#, - }, - VariateEntry { - field: r#"@taskNodeId"#, - description: r#"任务节点ID"#, - }, - VariateEntry { - field: r#"@flowFullName"#, - description: r#"流程名称"#, - }, - VariateEntry { - field: r#"@taskFullName"#, - description: r#"任务标题"#, - }, - VariateEntry { - field: r#"@launchUserId"#, - description: r#"发起用户ID"#, - }, - VariateEntry { - field: r#"@launchUserName"#, - description: r#"发起用户名称"#, - }, - VariateEntry { - field: r#"@flowOperatorUserId"#, - description: r#"当前操作用户ID"#, - }, -]; +pub use sspf_core::variate_catalog::*;