- 新增 platform::db::exec_params,收拢业务层 12 处裸 state.db.query - 新增 check-db-access.sh 护栏:白名单 3 文件,7 处命中 0 越界 - 平台侧需求写入 ssw-platform/docs/SSPF-BUSINESS-DB-ACCESS.md(目标 v0.5.0) - Cargo.toml 仍锁 v0.3.0,132 端点契约与响应形状未变
860 lines
34 KiB
Rust
860 lines
34 KiB
Rust
//! 账号层:**`base_user` / `base_role` / `base_role_relation`**(照上游 j7 同款)。
|
||
//!
|
||
//! 🔴 **B4 起,本文件不再读写本机 JSON 文件**(`data/accounts.json`):
|
||
//! 账号载体换成上游 j7 的 `base_user` 表 ⇒ 存量 JSON **不导入**(D5/D8),
|
||
//! 文件**保留不删**(运行期数据不擅自删),但**后端不再读取它**。
|
||
//!
|
||
//! ## 口令:官方双 md5 公式(**单向不可逆**)
|
||
//!
|
||
//! | 环节 | 口径 |
|
||
//! |---|---|
|
||
//! | 前端加密 | `md5(明文)` → AES-256-ECB-PKCS7 → hex(`platform::cipher`,**一字不改**) |
|
||
//! | 服务端解密 | 密文 hex → `md5(明文)`(32 个小写 hex) |
|
||
//! | **入库** | `f_password = md5(lower(md5(明文)) + lower(f_secretkey))` |
|
||
//! | 登录比对 | 解密得 `md5(明文)` → 拼 `lower(secretkey)` → 再 `md5` → 与 `f_password` 比 |
|
||
//!
|
||
//! 上游出处:`PasswordTokenGranter.java:186` 的
|
||
//! `Md5Util.getStringMd5(inputPwd + secretkey.toLowerCase())`(`inputPwd` 已是 `md5(明文)`)。
|
||
//!
|
||
//! 🔴 **改密不换 secretkey**(v3 spec §4.2;与官方一致)——改密只重算 `f_password`。
|
||
//! 🔴 **一次性换算不可逆**:从旧裸 md5 换到新公式需要**旧 md5**(前端手里那份)+ 新 secretkey。
|
||
//!
|
||
//! ## 权限三件套(照上游 §5.1)
|
||
//!
|
||
//! 1. **登录态**:`/api/oauth/Login` 成功 ⇒ 会话令牌;
|
||
//! 2. **角色码**:`base_role.f_en_code` ∈ {`tdcProvider`,`tdcConsumer`,`tdsReadOnly`}
|
||
//! (经 `base_role_relation` 关联用户)——SQL 形状逐字照抄上游 `AuthController#me`;
|
||
//! 3. **管理员位**:`base_user.f_is_administrator = 1`(**fail-closed**)⇒ 守用户管理端点。
|
||
//!
|
||
//! ⚠️ **D9 / S7**:`tdsReadOnly` **判据在、种子不种**(上游自身的不一致,照抄)。
|
||
|
||
use rand::RngCore;
|
||
use serde_json::Value;
|
||
|
||
use crate::platform::cipher::md5_hex;
|
||
use crate::platform::db::{query_json_params, query_scalar_text};
|
||
use crate::platform::state::AppState;
|
||
use crate::tdc::config::TdcConfig;
|
||
use crate::tdc::mapper::bind_refs;
|
||
|
||
/// 新建账号的初始口令(上游取 `base_sys_config.newUserDefaultPassword`,本端固定值)。
|
||
pub const DEFAULT_NEW_USER_PASSWORD: &str = "123456";
|
||
|
||
/// 首次启动引导的管理员账号名 / 口令 ⇒ **业务常量**(`tdc::constant`,一处定义)。
|
||
pub use crate::tdc::constant::{
|
||
DEFAULT_BOOTSTRAP_ADMIN_ACCOUNT as BOOTSTRAP_ADMIN_ACCOUNT,
|
||
DEFAULT_BOOTSTRAP_ADMIN_PASSWORD as BOOTSTRAP_ADMIN_PASSWORD,
|
||
};
|
||
|
||
/// 角色**判据**里的三个角色码(照抄上游 `AuthController#me` 的 `f_en_code IN (...)`)。
|
||
///
|
||
/// 🔴 `tdsReadOnly` 是**悬空码**:上游 `connector_seed` 只种了
|
||
/// `tdcProvider` / `tdcConsumer` / `user`(D9 / S7)⇒ 判据保留、种子不种。
|
||
pub const ROLE_CODES: &[&str] = &["tdcProvider", "tdcConsumer", "tdsReadOnly"];
|
||
|
||
/// 上游 `V1.0.1__connector_seed.sql` 种的三个角色(`f_id` / `f_full_name` / `f_en_code`)——**逐字照抄**。
|
||
pub const SEED_ROLES: &[(&str, &str, &str)] = &[
|
||
("a0000000-0000-4000-8000-000000000001", "TDC数据提供方", "tdcProvider"),
|
||
("a0000000-0000-4000-8000-000000000002", "TDC数据使用方", "tdcConsumer"),
|
||
("a0000000-0000-4000-8000-000000000003", "使用者", "user"),
|
||
];
|
||
|
||
/// 引导管理员绑定的角色码(上游 `connector_seed` 建的第三个角色 `user`)。
|
||
pub const BOOTSTRAP_ADMIN_ROLE: &str = "user";
|
||
|
||
/// 常量时间比较(**实现上收到平台层**,v3 spec §2.3.1 C11 ⇒ 全仓只有一份)。
|
||
pub use crate::platform::compare::constant_time_eq;
|
||
|
||
/// 账号层的失败:**业务失败**(code 400)与**服务端失败**(code 500)分开。
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub enum AccountError {
|
||
/// 业务失败:账号已存在 / 账号不存在 / 管理员账号不可删除 ……
|
||
Business(String),
|
||
/// 服务端失败:DB 读写出错。
|
||
Server(String),
|
||
}
|
||
|
||
impl AccountError {
|
||
pub fn msg(&self) -> &str {
|
||
match self {
|
||
AccountError::Business(m) | AccountError::Server(m) => m,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 一行账号(`base_user` 的一行)。
|
||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||
pub struct Account {
|
||
pub id: String,
|
||
pub account: String,
|
||
pub real_name: String,
|
||
/// `f_gender`(上游是 `varchar(50)`)⇒ 本仓**存文本、读成数字**(出参形状不变)。
|
||
pub gender: i64,
|
||
pub mobile_phone: Option<String>,
|
||
pub description: Option<String>,
|
||
/// 1 = 启用,0 = 禁用(上游 `enabledMark`)。
|
||
pub enabled_mark: i64,
|
||
/// 是否管理员(上游 `f_is_administrator`)⇒ 能不能管 `/api/permission/Users*`。
|
||
pub administrator: bool,
|
||
/// `f_password`(官方双 md5 公式的散列)。**永不回显**。
|
||
pub password_hash: String,
|
||
/// `f_secretkey`(每账号随机)。**永不回显**。
|
||
pub secretkey: String,
|
||
/// `f_creator_time`(DB `now()` ⇒ **服务器本地时区**),格式 `YYYY-MM-DD HH:MM:SS`。
|
||
pub creator_time: String,
|
||
}
|
||
|
||
/// 账号层引导的结果。
|
||
#[derive(Debug, Clone)]
|
||
pub struct AccountBootstrap {
|
||
/// 本次启动**新建**了引导管理员(`false` = 库里已有账号 ⇒ 幂等,不动)。
|
||
pub admin_created: bool,
|
||
/// 引导管理员的账号名。
|
||
pub admin_account: String,
|
||
}
|
||
|
||
// ==========================================================================
|
||
// 纯函数(口令公式 / id 生成 / 行映射)
|
||
// ==========================================================================
|
||
|
||
/// 官方口令公式:`md5(lower(md5(明文)) + lower(f_secretkey))`。
|
||
///
|
||
/// 🔴 入参 `plain_md5_hex` 是**明文的 md5 hex**(不是明文本身)——与上游
|
||
/// `PasswordTokenGranter` 的 `inputPwd` 同义。
|
||
pub fn official_password_hash(plain_md5_hex: &str, secretkey: &str) -> String {
|
||
md5_hex(&format!(
|
||
"{}{}",
|
||
plain_md5_hex.to_lowercase(),
|
||
secretkey.to_lowercase()
|
||
))
|
||
}
|
||
|
||
/// 上游 j7 的 id / 秘钥形状:`UUID.randomUUID().toString().toUpperCase()`(36 字符,带连字符)。
|
||
///
|
||
/// 🔴 与 `platform::ids::next_id()`(雪花号十进制串)**刻意不同**:
|
||
/// `base_*` 是上游 j7 的表 ⇒ 行 id 用 j7 的形状(`TdcLocalJ7SeedService` 就是这么插的),
|
||
/// 免得同一张表里混两种 id 风格。
|
||
pub fn new_j7_id() -> String {
|
||
let mut b = [0u8; 16];
|
||
rand::rngs::OsRng.fill_bytes(&mut b);
|
||
// RFC 4122 v4:version 位 + variant 位
|
||
b[6] = (b[6] & 0x0f) | 0x40;
|
||
b[8] = (b[8] & 0x3f) | 0x80;
|
||
let h = hex::encode(b).to_uppercase();
|
||
format!(
|
||
"{}-{}-{}-{}-{}",
|
||
&h[0..8],
|
||
&h[8..12],
|
||
&h[12..16],
|
||
&h[16..20],
|
||
&h[20..32]
|
||
)
|
||
}
|
||
|
||
/// 绑定参数占位符:Rust 侧只送 text,类型转换全交给 SQL(`platform::db` 的红线)。
|
||
///
|
||
/// 🔴 **必须双层 CAST**:只写 `CAST($1 AS text)` 时,参数被钉成 text,
|
||
/// 插进 `integer` / `character varying(50)` 列时 PG 会报
|
||
/// 「column is of type integer but expression is of type text」
|
||
/// ⇒ 必须再显式转一次到目标列类型。
|
||
fn p(idx: usize, ty: &str) -> String {
|
||
format!("CAST(CAST(${idx} AS text) AS {ty})", idx = idx)
|
||
}
|
||
|
||
/// 可空文本列的绑定表达式:**空串 ⇒ NULL**。
|
||
///
|
||
/// 🔴 为什么要这一层:出参里 `mobilePhone` / `description` 是 `null` 还是 `""`
|
||
/// 是**可观测**的(v3 spec W3「出参形状不变」)⇒ 传空串时必须落成 `NULL`,
|
||
/// 否则老账号的 `null` 会变成 `""`。
|
||
fn opt_p(idx: usize, ty: &str) -> String {
|
||
format!("NULLIF({}, '')", p(idx, ty))
|
||
}
|
||
|
||
/// 账号行的 SELECT 列(**只 SELECT 明确列**,永不 `SELECT *` —— 见 v3 spec C10 的同款纪律)。
|
||
const ACCOUNT_COLUMNS: &str = "f_id, f_account, \
|
||
COALESCE(f_real_name, '') AS f_real_name, \
|
||
COALESCE(f_gender, '') AS f_gender, \
|
||
f_mobile_phone, f_description, \
|
||
COALESCE(f_enabled_mark, 0) AS f_enabled_mark, \
|
||
COALESCE(f_is_administrator, 0) AS f_is_administrator, \
|
||
f_password, f_secretkey, \
|
||
COALESCE(to_char(f_creator_time, 'YYYY-MM-DD HH24:MI:SS'), '') AS f_creator_time";
|
||
|
||
/// 一行 JSON → [`Account`](列名取自 `ACCOUNT_COLUMNS`)。
|
||
fn row_to_account(row: &Value) -> Option<Account> {
|
||
let id = row.get("f_id")?.as_str()?.to_string();
|
||
let account = row
|
||
.get("f_account")
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let real_name = row
|
||
.get("f_real_name")
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
// 🔴 `f_gender` 上游是 `varchar(50)` ⇒ 存文本、读成数字(读不出数字 ⇒ 0 = 未知)。
|
||
let gender = row
|
||
.get("f_gender")
|
||
.and_then(|v| v.as_str())
|
||
.and_then(|s| s.trim().parse::<i64>().ok())
|
||
.unwrap_or(0);
|
||
let mobile_phone = row
|
||
.get("f_mobile_phone")
|
||
.and_then(|v| v.as_str())
|
||
.map(|s| s.to_string());
|
||
let description = row
|
||
.get("f_description")
|
||
.and_then(|v| v.as_str())
|
||
.map(|s| s.to_string());
|
||
let enabled_mark = row
|
||
.get("f_enabled_mark")
|
||
.and_then(|v| v.as_i64())
|
||
.unwrap_or(0);
|
||
let administrator = row
|
||
.get("f_is_administrator")
|
||
.and_then(|v| v.as_i64())
|
||
.unwrap_or(0)
|
||
== 1;
|
||
let password_hash = row
|
||
.get("f_password")
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let secretkey = row
|
||
.get("f_secretkey")
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
let creator_time = row
|
||
.get("f_creator_time")
|
||
.and_then(|v| v.as_str())
|
||
.unwrap_or_default()
|
||
.to_string();
|
||
Some(Account {
|
||
id,
|
||
account,
|
||
real_name,
|
||
gender,
|
||
mobile_phone,
|
||
description,
|
||
enabled_mark,
|
||
administrator,
|
||
password_hash,
|
||
secretkey,
|
||
creator_time,
|
||
})
|
||
}
|
||
|
||
/// 🔴 存活谓词(对齐上游 `TdcCrudController.ALIVE`)。
|
||
const ALIVE_USER: &str = "(f_delete_mark IS NULL OR f_delete_mark = 0)";
|
||
|
||
// ==========================================================================
|
||
// 读
|
||
// ==========================================================================
|
||
|
||
/// 按 `f_id` 取一行账号(存活)。
|
||
pub async fn find(state: &AppState, id: &str) -> Result<Option<Account>, AccountError> {
|
||
let sql = format!(
|
||
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE f_id = CAST($1 AS text) AND {ALIVE_USER} LIMIT 1"
|
||
);
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), &sql, &[&id.to_string()]).await
|
||
};
|
||
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号失败: {}", e)))?;
|
||
Ok(rows.first().and_then(row_to_account))
|
||
}
|
||
|
||
/// 按账号名取一行账号(存活)。
|
||
pub async fn find_by_account(
|
||
state: &AppState,
|
||
account: &str,
|
||
) -> Result<Option<Account>, AccountError> {
|
||
let sql = format!(
|
||
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE f_account = CAST($1 AS text) AND {ALIVE_USER} \
|
||
ORDER BY f_creator_time DESC LIMIT 1"
|
||
);
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), &sql, &[&account.to_string()]).await
|
||
};
|
||
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号失败: {}", e)))?;
|
||
Ok(rows.first().and_then(row_to_account))
|
||
}
|
||
|
||
/// 管理员位(`base_user.f_is_administrator = 1`)。
|
||
///
|
||
/// 🔴 **fail-closed**:查不到行 / 查出错 ⇒ `false`(对齐上游 `TdcConnectorAdminGuard`)。
|
||
pub async fn is_administrator(state: &AppState, id: &str) -> bool {
|
||
let sql = "SELECT COALESCE(f_is_administrator, 0) AS f_is_administrator FROM base_user \
|
||
WHERE f_id = CAST($1 AS text) AND (f_delete_mark IS NULL OR f_delete_mark = 0) LIMIT 1";
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), sql, &[&id.to_string()]).await
|
||
};
|
||
match rows {
|
||
Ok(rows) => rows
|
||
.first()
|
||
.and_then(|r| r.get("f_is_administrator"))
|
||
.and_then(|v| v.as_i64())
|
||
.map(|v| v == 1)
|
||
.unwrap_or(false),
|
||
Err(_) => false,
|
||
}
|
||
}
|
||
|
||
/// 角色码(**逐字照抄上游 `AuthController#me` 的 SQL 形状**)。
|
||
///
|
||
/// ```sql
|
||
/// SELECT b.f_en_code FROM base_role b JOIN base_role_relation r ON r.f_role_id = b.f_id
|
||
/// WHERE r.f_object_type = 'user' AND r.f_object_id = ?
|
||
/// AND (b.f_delete_mark IS NULL OR b.f_delete_mark = 0)
|
||
/// AND b.f_en_code IN ('tdcProvider','tdcConsumer','tdsReadOnly')
|
||
/// ```
|
||
///
|
||
/// ⚠️ 判据里的三个码与**种子**里的三个角色**不是同一组**(D9 / S7):
|
||
/// `tdsReadOnly` 在判据里、**不在种子里**;`user` 在种子里、**不在判据里**
|
||
/// ⇒ 绑了 `user` 角色的账号(本仓的引导管理员)在这条 SQL 下**查不到任何角色码**
|
||
/// —— 这正是上游自己的口径,照抄。
|
||
pub async fn role_codes(state: &AppState, user_id: &str) -> Vec<String> {
|
||
let in_list = ROLE_CODES
|
||
.iter()
|
||
.map(|c| format!("'{}'", c))
|
||
.collect::<Vec<_>>()
|
||
.join(", ");
|
||
let sql = format!(
|
||
"SELECT b.f_en_code FROM base_role b JOIN base_role_relation r ON r.f_role_id = b.f_id \
|
||
WHERE r.f_object_type = 'user' AND r.f_object_id = CAST($1 AS text) \
|
||
AND (b.f_delete_mark IS NULL OR b.f_delete_mark = 0) \
|
||
AND b.f_en_code IN ({})",
|
||
in_list
|
||
);
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), &sql, &[&user_id.to_string()]).await
|
||
};
|
||
let Ok(rows) = rows else {
|
||
return Vec::new();
|
||
};
|
||
rows.iter()
|
||
.filter_map(|r| r.get("f_en_code"))
|
||
.filter_map(|v| v.as_str())
|
||
.map(|s| s.to_string())
|
||
.collect()
|
||
}
|
||
|
||
/// 分页列账号(`keyword` 命中账号名或姓名;空 ⇒ 全量)。
|
||
///
|
||
/// 返回 `(当页行, 总条数)`。
|
||
pub async fn list(
|
||
state: &AppState,
|
||
keyword: &str,
|
||
page: usize,
|
||
size: usize,
|
||
) -> Result<(Vec<Account>, i64), AccountError> {
|
||
let kw = keyword.trim().to_lowercase();
|
||
let where_clause = if kw.is_empty() {
|
||
ALIVE_USER.to_string()
|
||
} else {
|
||
format!(
|
||
"{ALIVE_USER} AND (lower(f_account) LIKE '%' || CAST($1 AS text) || '%' \
|
||
OR lower(COALESCE(f_real_name, '')) LIKE '%' || CAST($1 AS text) || '%')"
|
||
)
|
||
};
|
||
let binds: Vec<String> = if kw.is_empty() {
|
||
Vec::new()
|
||
} else {
|
||
vec![kw.clone()]
|
||
};
|
||
let refs = bind_refs(&binds);
|
||
|
||
let count_sql = format!("SELECT count(*)::text FROM base_user WHERE {}", where_clause);
|
||
let total: i64 = {
|
||
let _g = state.db_lock.lock().await;
|
||
match query_scalar_text(state.db.as_ref(), &count_sql, &refs).await {
|
||
Ok(Some(t)) => t.trim().parse().unwrap_or(0),
|
||
Ok(None) => 0,
|
||
Err(e) => return Err(AccountError::Server(format!("统计账号数失败: {}", e))),
|
||
}
|
||
};
|
||
// 🔴 `page` / `size` 由调用方**夹紧**过(page ≥ 1、1 ≤ size ≤ 500)⇒ 内联进 SQL 是安全的
|
||
// (与通用 CRUD 引擎的 `LIMIT/OFFSET` 内联同款做法)。
|
||
let offset = page.saturating_sub(1).saturating_mul(size);
|
||
let sql = format!(
|
||
"SELECT {ACCOUNT_COLUMNS} FROM base_user WHERE {} ORDER BY f_creator_time DESC, f_id LIMIT {} OFFSET {}",
|
||
where_clause, size, offset
|
||
);
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), &sql, &refs).await
|
||
};
|
||
let rows = rows.map_err(|e| AccountError::Server(format!("查询账号列表失败: {}", e)))?;
|
||
let list: Vec<Account> = rows.iter().filter_map(row_to_account).collect();
|
||
Ok((list, total))
|
||
}
|
||
|
||
// ==========================================================================
|
||
// 写
|
||
// ==========================================================================
|
||
|
||
/// 新建账号。
|
||
///
|
||
/// 🔴 **初始口令 = 系统默认口令**(`DEFAULT_NEW_USER_PASSWORD`),
|
||
/// **不取请求里的 password**(上游口径:新建账号的初始口令是系统默认值)。
|
||
/// 🔴 每个账号一条**独立随机** `f_secretkey` ⇒ 两个同名口令的不同账号散列不同。
|
||
pub async fn create(
|
||
state: &AppState,
|
||
operator: &str,
|
||
account: &str,
|
||
real_name: &str,
|
||
gender: i64,
|
||
mobile_phone: Option<&str>,
|
||
description: Option<&str>,
|
||
) -> Result<Account, AccountError> {
|
||
let account = account.trim();
|
||
if account.is_empty() {
|
||
return Err(AccountError::Business("账号必填".to_string()));
|
||
}
|
||
let dup = find_by_account(state, account).await?;
|
||
if dup.is_some() {
|
||
return Err(AccountError::Business("账号已存在".to_string()));
|
||
}
|
||
let secretkey = new_j7_id();
|
||
let id = new_j7_id();
|
||
let password_hash = official_password_hash(&md5_hex(DEFAULT_NEW_USER_PASSWORD), &secretkey);
|
||
let sql = format!(
|
||
"INSERT INTO base_user (f_id, f_account, f_real_name, f_gender, f_mobile_phone, f_description, \
|
||
f_password, f_secretkey, f_is_administrator, f_enabled_mark, f_creator_time, f_creator_user_id, \
|
||
f_tenant_id) \
|
||
VALUES ({}, {}, {}, {}, {}, {}, {}, {}, 0, 1, NOW(), {}, '0')",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(50)"),
|
||
p(3, "character varying(50)"),
|
||
p(4, "character varying(50)"),
|
||
opt_p(5, "character varying(20)"),
|
||
opt_p(6, "character varying(500)"),
|
||
p(7, "character varying(50)"),
|
||
p(8, "character varying(50)"),
|
||
p(9, "character varying(50)"),
|
||
);
|
||
let params: Vec<String> = vec![
|
||
id.clone(),
|
||
account.to_string(),
|
||
real_name.trim().to_string(),
|
||
gender.to_string(),
|
||
mobile_phone.unwrap_or_default().to_string(),
|
||
description.unwrap_or_default().to_string(),
|
||
password_hash,
|
||
secretkey,
|
||
operator.to_string(),
|
||
];
|
||
let refs = bind_refs(¶ms);
|
||
{
|
||
let _g = state.db_lock.lock().await;
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("新建账号失败: {}", e)))?;
|
||
}
|
||
find(state, &id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Server("新建账号后读不回来".to_string()))
|
||
}
|
||
|
||
/// 更新资料(**不动口令**)。
|
||
pub async fn update(
|
||
state: &AppState,
|
||
operator: &str,
|
||
id: &str,
|
||
real_name: &str,
|
||
gender: i64,
|
||
mobile_phone: Option<&str>,
|
||
description: Option<&str>,
|
||
) -> Result<Account, AccountError> {
|
||
let current = find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
|
||
let sql = format!(
|
||
"UPDATE base_user SET f_real_name = {}, f_gender = {}, f_mobile_phone = {}, f_description = {}, \
|
||
f_last_modify_time = NOW(), f_last_modify_user_id = {} \
|
||
WHERE f_id = CAST($8 AS text) AND {ALIVE_USER}",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(50)"),
|
||
opt_p(3, "character varying(20)"),
|
||
opt_p(4, "character varying(500)"),
|
||
p(5, "character varying(50)"),
|
||
);
|
||
let params: Vec<String> = vec![
|
||
real_name.trim().to_string(),
|
||
gender.to_string(),
|
||
mobile_phone.unwrap_or_default().to_string(),
|
||
description.unwrap_or_default().to_string(),
|
||
operator.to_string(),
|
||
id.to_string(),
|
||
];
|
||
let refs = bind_refs(¶ms);
|
||
{
|
||
let _g = state.db_lock.lock().await;
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("更新账号失败: {}", e)))?;
|
||
}
|
||
let _ = current;
|
||
find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
|
||
}
|
||
|
||
/// 删除(**逻辑删除**;**管理员账号不许删**)。
|
||
pub async fn remove(state: &AppState, operator: &str, id: &str) -> Result<(), AccountError> {
|
||
let current = find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
|
||
if current.administrator {
|
||
return Err(AccountError::Business("管理员账号不可删除".to_string()));
|
||
}
|
||
let sql = format!(
|
||
"UPDATE base_user SET f_delete_mark = 1, f_delete_time = NOW(), f_delete_user_id = {} \
|
||
WHERE f_id = CAST($2 AS text) AND {ALIVE_USER}",
|
||
p(1, "character varying(50)")
|
||
);
|
||
let params: Vec<String> = vec![operator.to_string(), id.to_string()];
|
||
let refs = bind_refs(¶ms);
|
||
let _g = state.db_lock.lock().await;
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map(|_| ())
|
||
.map_err(|e| AccountError::Server(format!("删除账号失败: {}", e)))
|
||
}
|
||
|
||
/// 启用 / 禁用。
|
||
pub async fn set_enabled(
|
||
state: &AppState,
|
||
operator: &str,
|
||
id: &str,
|
||
enabled_mark: i64,
|
||
) -> Result<Account, AccountError> {
|
||
let current = find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
|
||
let mark = if enabled_mark == 0 { 0 } else { 1 };
|
||
let sql = format!(
|
||
"UPDATE base_user SET f_enabled_mark = {}, f_last_modify_time = NOW(), f_last_modify_user_id = {} \
|
||
WHERE f_id = CAST($3 AS text) AND {ALIVE_USER}",
|
||
p(1, "integer"),
|
||
p(2, "character varying(50)")
|
||
);
|
||
let params: Vec<String> = vec![
|
||
mark.to_string(),
|
||
operator.to_string(),
|
||
id.to_string(),
|
||
];
|
||
let refs = bind_refs(¶ms);
|
||
{
|
||
let _g = state.db_lock.lock().await;
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("设置账号状态失败: {}", e)))?;
|
||
}
|
||
let _ = current;
|
||
find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
|
||
}
|
||
|
||
/// 重设口令(传入的是 `md5(明文)`,32 个 hex 字符)。
|
||
///
|
||
/// 🔴 **改密不换 secretkey**(v3 spec §4.2;与官方一致)⇒ 只重算 `f_password`。
|
||
pub async fn reset_password(
|
||
state: &AppState,
|
||
operator: &str,
|
||
id: &str,
|
||
password_md5: &str,
|
||
) -> Result<Account, AccountError> {
|
||
let current = find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))?;
|
||
let password_hash = official_password_hash(password_md5, ¤t.secretkey);
|
||
let sql = format!(
|
||
"UPDATE base_user SET f_password = {}, f_change_password_date = NOW(), \
|
||
f_last_modify_time = NOW(), f_last_modify_user_id = {} \
|
||
WHERE f_id = CAST($3 AS text) AND {ALIVE_USER}",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(50)")
|
||
);
|
||
let params: Vec<String> = vec![
|
||
password_hash,
|
||
operator.to_string(),
|
||
id.to_string(),
|
||
];
|
||
let refs = bind_refs(¶ms);
|
||
{
|
||
let _g = state.db_lock.lock().await;
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("重设口令失败: {}", e)))?;
|
||
}
|
||
find(state, id)
|
||
.await?
|
||
.ok_or_else(|| AccountError::Business("账号不存在".to_string()))
|
||
}
|
||
|
||
// ==========================================================================
|
||
// 引导(幂等)
|
||
// ==========================================================================
|
||
|
||
/// 账号层引导:种三个角色 +(库里没有账号时)引导**一个**管理员。
|
||
///
|
||
/// 🔴 **幂等**:角色用 `WHERE NOT EXISTS` 种;管理员只在 **`base_user` 没有存活行**时建。
|
||
/// 重复启动不会覆盖既有账号(口令只由引导决定)。
|
||
/// 🔴 全程持 `db_lock` ⇒ 进程内串行(pglite 单 backend)。
|
||
pub async fn bootstrap_account_layer(
|
||
state: &AppState,
|
||
tdc_config: &TdcConfig,
|
||
) -> Result<AccountBootstrap, AccountError> {
|
||
let account = {
|
||
let raw = tdc_config.bootstrap_admin_account.trim();
|
||
if raw.is_empty() {
|
||
BOOTSTRAP_ADMIN_ACCOUNT.to_string()
|
||
} else {
|
||
raw.to_string()
|
||
}
|
||
};
|
||
let password = tdc_config
|
||
.bootstrap_admin_password
|
||
.clone()
|
||
.unwrap_or_else(|| BOOTSTRAP_ADMIN_PASSWORD.to_string());
|
||
|
||
let _g = state.db_lock.lock().await;
|
||
|
||
// ① 三个角色(照抄上游 `connector_seed` 的三行)。
|
||
for (id, full_name, en_code) in SEED_ROLES {
|
||
let sql = format!(
|
||
"INSERT INTO base_role (f_id, f_full_name, f_en_code, f_type, f_enabled_mark, f_sort_code, \
|
||
f_creator_time, f_creator_user_id, f_delete_mark, f_tenant_id, f_global_mark) \
|
||
SELECT {}, {}, {}, 'user', 1, 0, NOW(), 'admin', NULL, '0', 0 \
|
||
WHERE NOT EXISTS (SELECT 1 FROM base_role WHERE f_en_code = {})",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(200)"),
|
||
p(3, "character varying(200)"),
|
||
p(3, "character varying(200)"),
|
||
);
|
||
let params: Vec<String> = vec![
|
||
id.to_string(),
|
||
full_name.to_string(),
|
||
en_code.to_string(),
|
||
];
|
||
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
|
||
.iter()
|
||
.map(|s| s as &(dyn pglite::ToSql + Sync))
|
||
.collect();
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("种角色 {} 失败: {}", en_code, e)))?;
|
||
}
|
||
|
||
// ② `base_user` 有没有存活行 ⇒ 有则不引导(幂等)。
|
||
let count = query_scalar_text(
|
||
state.db.as_ref(),
|
||
&format!("SELECT count(*)::text FROM base_user WHERE {}", ALIVE_USER),
|
||
&[],
|
||
)
|
||
.await
|
||
.map_err(|e| AccountError::Server(format!("统计账号数失败: {}", e)))?;
|
||
let existing: i64 = count
|
||
.and_then(|t| t.trim().parse().ok())
|
||
.unwrap_or(0);
|
||
if existing > 0 {
|
||
return Ok(AccountBootstrap {
|
||
admin_created: false,
|
||
admin_account: account,
|
||
});
|
||
}
|
||
|
||
// ③ 引导一个管理员(`f_is_administrator = 1`)。
|
||
let secretkey = new_j7_id();
|
||
let id = new_j7_id();
|
||
let password_hash = official_password_hash(&md5_hex(&password), &secretkey);
|
||
let sql = format!(
|
||
"INSERT INTO base_user (f_id, f_account, f_real_name, f_gender, f_description, \
|
||
f_password, f_secretkey, f_is_administrator, f_enabled_mark, f_creator_time, \
|
||
f_creator_user_id, f_tenant_id) \
|
||
VALUES ({}, {}, '管理员', '1', '首次启动引导', {}, {}, 1, 1, NOW(), 'admin', '0')",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(50)"),
|
||
p(3, "character varying(50)"),
|
||
p(4, "character varying(50)"),
|
||
);
|
||
let params: Vec<String> = vec![id.clone(), account.clone(), password_hash, secretkey];
|
||
let refs = bind_refs(¶ms);
|
||
crate::platform::db::exec_params(&state.db, &sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("引导管理员账号失败: {}", e)))?;
|
||
|
||
// ④ 绑定角色(`f_object_type='user'` + `f_object_id=<admin f_id>`)⇒ 管理员具备 `user` 角色码。
|
||
let role_id = query_scalar_text(
|
||
state.db.as_ref(),
|
||
"SELECT f_id::text FROM base_role WHERE f_en_code = CAST($1 AS text) LIMIT 1",
|
||
&[&BOOTSTRAP_ADMIN_ROLE.to_string()],
|
||
)
|
||
.await
|
||
.ok()
|
||
.flatten();
|
||
if let Some(role_id) = role_id {
|
||
let rel_sql = format!(
|
||
"INSERT INTO base_role_relation (f_id, f_role_id, f_object_type, f_object_id, \
|
||
f_sort_code, f_creator_time, f_creator_user_id, f_delete_mark, f_tenant_id) \
|
||
SELECT {}, {}, 'user', {}, 0, NOW(), 'admin', NULL, '0' \
|
||
WHERE NOT EXISTS (SELECT 1 FROM base_role_relation \
|
||
WHERE f_object_type = 'user' AND f_object_id = {})",
|
||
p(1, "character varying(50)"),
|
||
p(2, "character varying(50)"),
|
||
p(3, "character varying(50)"),
|
||
p(3, "character varying(50)"),
|
||
);
|
||
let params: Vec<String> = vec![new_j7_id(), role_id, id.clone()];
|
||
let refs: Vec<&(dyn pglite::ToSql + Sync)> = params
|
||
.iter()
|
||
.map(|s| s as &(dyn pglite::ToSql + Sync))
|
||
.collect();
|
||
crate::platform::db::exec_params(&state.db, &rel_sql, &refs).await
|
||
.map_err(|e| AccountError::Server(format!("绑定管理员角色失败: {}", e)))?;
|
||
}
|
||
|
||
Ok(AccountBootstrap {
|
||
admin_created: true,
|
||
admin_account: account,
|
||
})
|
||
}
|
||
|
||
/// 是否**还有管理员账号在用默认口令**(`admin`)。
|
||
///
|
||
/// 🔴 供 `TDC_STRICT_SECRETS=1` 的护栏用:默认口令是**公开已知**的
|
||
/// ⇒ 生产档必须拒绝启动;口令改过(或引导时用环境变量覆盖过)就放行。
|
||
/// 判据是「**任何管理员账号**的散列等于默认散列」⇒ 换个账号名继续用
|
||
/// 默认口令**也**会被拦(fail-closed)。
|
||
pub async fn bootstrap_admin_uses_default_password(state: &AppState) -> bool {
|
||
let default_md5 = md5_hex(BOOTSTRAP_ADMIN_PASSWORD);
|
||
let sql = format!(
|
||
"SELECT f_password, f_secretkey FROM base_user \
|
||
WHERE COALESCE(f_is_administrator, 0) = 1 AND {ALIVE_USER}"
|
||
);
|
||
let rows = {
|
||
let _g = state.db_lock.lock().await;
|
||
query_json_params(state.db.as_ref(), &sql, &[]).await
|
||
};
|
||
let Ok(rows) = rows else {
|
||
// 🔴 查不出来 ⇒ **fail-closed**(当作「还在用默认口令」⇒ 生产档拒绝启动)。
|
||
return true;
|
||
};
|
||
rows.iter().any(|r| {
|
||
let hash = r.get("f_password").and_then(|v| v.as_str()).unwrap_or("");
|
||
let key = r.get("f_secretkey").and_then(|v| v.as_str()).unwrap_or("");
|
||
!key.is_empty() && constant_time_eq(&official_password_hash(&default_md5, key), hash)
|
||
})
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
/// 🔴 **上游公式自证**(向量用系统 `md5` 独立算出,不是本仓自己算自己证):
|
||
///
|
||
/// | 明文 | `md5(明文)` | secretkey | 期望 `f_password` |
|
||
/// |---|---|---|---|
|
||
/// | `123456` | `e10adc3949ba59abbe56e057f20f883e` | `A1B2C3D4` | `f5aed9cb34072037071de9e90f3ef650` |
|
||
/// | `123456` | `e10adc3949ba59abbe56e057f20f883e` | `00-11-22` | `cf1150bde4e2f01f1f0a4558a800cbb0` |
|
||
///
|
||
/// (secretkey 故意用**大写**与**带连字符**两种形状 ⇒ 同时钉住 `lower()` 归一。)
|
||
#[test]
|
||
fn official_password_hash_matches_the_upstream_formula() {
|
||
assert_eq!(
|
||
official_password_hash(&md5_hex("123456"), "A1B2C3D4"),
|
||
"f5aed9cb34072037071de9e90f3ef650"
|
||
);
|
||
assert_eq!(
|
||
official_password_hash(&md5_hex("123456"), "00-11-22"),
|
||
"cf1150bde4e2f01f1f0a4558a800cbb0"
|
||
);
|
||
}
|
||
|
||
/// 🔴 公式**不是**裸 md5(否则整条「双 md5」白做了)。
|
||
#[test]
|
||
fn official_password_hash_is_not_the_bare_md5() {
|
||
let bare = md5_hex("123456");
|
||
let with_key = official_password_hash(&bare, "A1B2C3D4");
|
||
assert_ne!(with_key, bare);
|
||
}
|
||
|
||
/// 公式对 secretkey **大小写不敏感**(上游 `secretkey.toLowerCase()`)。
|
||
#[test]
|
||
fn official_password_hash_lowercases_both_sides() {
|
||
let bare = md5_hex("123456");
|
||
assert_eq!(
|
||
official_password_hash(&bare, "A1B2C3D4"),
|
||
official_password_hash(&bare, "a1b2c3d4")
|
||
);
|
||
assert_eq!(
|
||
official_password_hash(&bare.to_uppercase(), "A1B2C3D4"),
|
||
official_password_hash(&bare, "A1B2C3D4")
|
||
);
|
||
}
|
||
|
||
/// j7 的 id 形状:36 字符、带连字符、全大写 hex。
|
||
#[test]
|
||
fn j7_id_shape_matches_the_upstream_uuid_uppercase() {
|
||
let id = new_j7_id();
|
||
assert_eq!(id.len(), 36, "UUID 形状:{}", id);
|
||
assert_eq!(id.chars().filter(|c| *c == '-').count(), 4);
|
||
assert!(
|
||
id.chars().all(|c| c.is_ascii_hexdigit() || c == '-'),
|
||
"j7 id 应是 hex + 连字符:{}",
|
||
id
|
||
);
|
||
assert_ne!(id, new_j7_id(), "每次都应是新的随机 id");
|
||
}
|
||
|
||
/// 角色判据三件套照上游(`tdsReadOnly` 判据在、种子不种 ⇒ D9 / S7)。
|
||
#[test]
|
||
fn role_codes_are_the_upstream_three() {
|
||
assert_eq!(ROLE_CODES, &["tdcProvider", "tdcConsumer", "tdsReadOnly"]);
|
||
// 种子里的三个角色(上游 `connector_seed` 的三行)
|
||
let seeded: Vec<&str> = SEED_ROLES.iter().map(|(_, _, code)| *code).collect();
|
||
assert_eq!(seeded, &["tdcProvider", "tdcConsumer", "user"]);
|
||
// 🔴 判据里有、种子里没有的悬空码
|
||
assert!(ROLE_CODES.contains(&"tdsReadOnly"));
|
||
assert!(!seeded.contains(&"tdsReadOnly"));
|
||
// 🔴 种子里有、判据里没有的(`user` 角色绑上去也查不出角色码 —— 上游同口径)
|
||
assert!(seeded.contains(&"user"));
|
||
assert!(!ROLE_CODES.contains(&"user"));
|
||
}
|
||
|
||
/// 引导管理员绑的角色码 = `user`(上游 `connector_seed` 的第三个角色)。
|
||
#[test]
|
||
fn bootstrap_admin_binds_the_user_role() {
|
||
assert_eq!(BOOTSTRAP_ADMIN_ROLE, "user");
|
||
}
|
||
|
||
/// 行映射:`f_gender` 是 varchar ⇒ 读成数字;读不出数字 ⇒ 0。
|
||
#[test]
|
||
fn row_mapping_reads_gender_as_a_number() {
|
||
let row = serde_json::json!({
|
||
"f_id": "U-1",
|
||
"f_account": "admin",
|
||
"f_real_name": "管理员",
|
||
"f_gender": "1",
|
||
"f_mobile_phone": null,
|
||
"f_description": null,
|
||
"f_enabled_mark": 1,
|
||
"f_is_administrator": 1,
|
||
"f_password": "hash",
|
||
"f_secretkey": "key",
|
||
"f_creator_time": "2026-10-26 10:00:00",
|
||
});
|
||
let a = row_to_account(&row).expect("应能映射");
|
||
assert_eq!(a.id, "U-1");
|
||
assert_eq!(a.gender, 1);
|
||
assert!(a.administrator);
|
||
assert_eq!(a.enabled_mark, 1);
|
||
assert_eq!(a.creator_time, "2026-10-26 10:00:00");
|
||
assert!(a.mobile_phone.is_none());
|
||
|
||
let mut bad = row.clone();
|
||
bad["f_gender"] = serde_json::json!("男");
|
||
assert_eq!(row_to_account(&bad).unwrap().gender, 0);
|
||
}
|
||
}
|