feat(face-b): 系统服务族落地(面 B 批次 15,+39 端点)

多语言/表单套件/缓存管理/任务调度/IM 会话/收藏菜单/公式目录/系统监控 + 三处
Actions/Export;新表 8 张(官方 DDL 逐字)⇒ tables 65,BASE_TABLES 62。

影响:
- 多语言是「一行一语种 + f_group_id 聚组」,列表 id = groupId;tableHead 的列来自
  字典 Language(seed 按官方初始库种子化);PUT 时 map 里没有的语种要删掉。
- CacheManage 落到本仓真实的内存会话表:DELETE 真的把人踢下线、ClearAll 保留操作者
  自己、overdueTime 恒 null(会话不过期,不编时间)、绝不把 token 放进响应。
- scheduletask 只登记不执行(本仓无 XXL-JOB):runCount 恒 0、lastRunTime/nextRunTime
  恒 null、TaskMethods 返空 list(返错会让新建表单整条红)。
- 三处 Export 与 BaseLang 模板/导入 = 明确业务失败(无文件服务),不返假 url;
  Kit 那条尤其不能用 data:null(官方前端 res.data.url 会抛 JS 异常)。
- Monitor 真读宿主机指标;macOS 的 CPU 占空比用负载均值近似(契约标 partial)。

顺手修掉 fe-api-inventory.py 的嵌套模板串截断(真因):内层反引号会截断 URL、内层 }
会截断变量替换 ⇒ 产出畸形路径,让 system 永远差 2 条。改成深度配对 + 丢掉「拼查询串
的三元片段」后,system 缺口 41 → 0(196/196)。另把 3 条「官方前端声明但官方后端
从无映射、也无人调用」的死接口记进 [OFFICIAL] 的 oos(带判据,不进分母)。

回归测试 tests/batch15_it.rs 12 条;全量 610 passed / 0 failed;verify.sh 全绿。
This commit is contained in:
admin committed 2026-11-02 10:04:42 +08:00
1 parent e961904252
commit c82a7d1f3d
16 files changed
+5117 -134

No files matched your search

+186
View File
@@ -1504,3 +1504,189 @@ CREATE TABLE base_data_interface_variate (
f_field VARCHAR(50),
PRIMARY KEY (f_id, f_tenant_id)
);
-- ---------------------------------------------------------------------------
-- 系统服务族(批次 15)—— 多语言 / 套件 / 任务调度 / IM 会话 / 常用菜单
-- 全部列与官方 JNPF 7.0 的 PostgreSQL DDL 逐字一致(行号见各表注释)。
-- ---------------------------------------------------------------------------
-- 多语言词条(官方第 9113 行,`base_language`)
-- 🔴 **一行 = 一个语种**,同一翻译标记用 `f_group_id` 聚成一组:
-- 前端列表按组返回 `{id: groupId, code: enCode, typeName, <language>: <fullName>}`。
-- ⇒ `f_en_code` 上**没有**唯一约束(同组多行必然重复),判重要跨组做。
CREATE TABLE base_language (
f_id VARCHAR(50) NOT NULL,
f_group_id VARCHAR(50),
f_en_code VARCHAR(200),
f_full_name VARCHAR(500),
f_language VARCHAR(50),
f_type INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 表单套件(官方第 9165 行,`base_visual_kit`)
-- `f_form_data` 是整套套件设计内容的 JSON 串(前端原样存取)。
CREATE TABLE base_visual_kit (
f_id VARCHAR(50) NOT NULL,
f_full_name VARCHAR(200),
f_en_code VARCHAR(200),
f_category VARCHAR(50),
f_form_data TEXT,
f_icon VARCHAR(255),
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 任务调度(官方第 9203 行,`base_time_task`)
-- 🔴 官方 7.0 把**执行**交给 XXL-JOB(`RestScheduleTaskUtil`),这张表在官方是**登记表**;
-- 本仓没有调度器 ⇒ 同样只做登记(见 `face_b.rs` 的 scheduletask 段说明)。
CREATE TABLE base_time_task (
f_id VARCHAR(50) NOT NULL,
f_en_code VARCHAR(200),
f_full_name VARCHAR(200),
f_execute_type INTEGER,
f_execute_content TEXT,
f_execute_cycle_json TEXT,
f_last_run_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_next_run_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_run_count INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 任务调度日志(官方第 9241 行,`base_time_task_log`)
-- 一次执行一行;`f_run_result` = 1 成功 / 0 失败(官方无枚举类,前端按 !=1 判失败)。
CREATE TABLE base_time_task_log (
f_id VARCHAR(50) NOT NULL,
f_task_id VARCHAR(50),
f_run_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_run_result INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- IM 会话(官方第 9279 行,`base_im_reply`)
-- 一行 = 「我」与某人一个会话;`f_user_id` 是会话归属人,`f_receive_user_id` 是对方。
CREATE TABLE base_im_reply (
f_id VARCHAR(50) NOT NULL,
f_user_id VARCHAR(50),
f_receive_user_id VARCHAR(50),
f_receive_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- IM 消息内容(官方第 9317 行,`base_im_content`)
-- 未读数 = 该会话里 `f_receive_user_id = 我 AND f_delete_mark = 0` 的行数。
CREATE TABLE base_im_content (
f_id VARCHAR(50) NOT NULL,
f_send_user_id VARCHAR(50),
f_send_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_receive_user_id VARCHAR(50),
f_receive_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_content TEXT,
f_content_type VARCHAR(50),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 常用(收藏)菜单(官方第 9459 行,`base_module_data`)
-- 一行 = 「我」收藏了一个菜单;`f_module_id` 指向 `base_module.f_id`。
CREATE TABLE base_module_data (
f_id VARCHAR(50) NOT NULL,
f_module_type VARCHAR(50),
f_module_id VARCHAR(50),
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_system_id VARCHAR(50),
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_sort_code BIGINT,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
PRIMARY KEY (f_id, f_tenant_id)
);
-- 菜单访问次数(官方第 9499 行,`base_module_use_num`)
-- 一行 = 「我」对某菜单的累计点击数;`POST /MenuData/useModuleNum/{id}` 自增。
CREATE TABLE base_module_use_num (
f_id VARCHAR(50) NOT NULL,
f_user_id VARCHAR(50),
f_module_id VARCHAR(50),
f_use_num INTEGER,
f_description VARCHAR(500),
f_enabled_mark INTEGER,
f_sort_code BIGINT,
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_last_modify_user_id VARCHAR(50),
f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_user_id VARCHAR(50),
f_delete_mark INTEGER,
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
f_system_code VARCHAR(50),
PRIMARY KEY (f_id, f_tenant_id)
);
+13 -1
View File
@@ -57,7 +57,9 @@ use ssw_platform::routes;
/// 系统数据批次(2026-11-02 批次 13)新增 `base_province` / `base_common_variate` ⇒ **50 张**。
/// 数据中心批次(2026-11-02 批次 14)新增 `base_data_type_mapping` / `base_data_base` /
/// `base_data_type_relation` / `base_data_interface_variate` ⇒ **54 张**。
const BASE_TABLES: [&str; 54] = [
/// 系统服务批次(2026-11-02 批次 15)新增多语言 / 套件 / 调度两表 / IM 两表 / 常用两表
/// ⇒ **62 张**。
const BASE_TABLES: [&str; 62] = [
"base_group",
"base_user",
"base_role",
@@ -132,6 +134,16 @@ const BASE_TABLES: [&str; 54] = [
"base_data_base",
"base_data_type_relation",
"base_data_interface_variate",
// 🔴 系统服务批次(2026-11-02 批次 15):多语言(一行一语种,按 `f_group_id` 聚组)/
// 表单套件 / 任务调度登记 + 执行日志 / IM 会话 + 消息 / 收藏菜单 + 菜单点击计数。
"base_language",
"base_visual_kit",
"base_time_task",
"base_time_task_log",
"base_im_reply",
"base_im_content",
"base_module_data",
"base_module_use_num",
];
/// 命令行解析的结果(**纯数据**,便于单测)。
File diff suppressed because it is too large. Load diff
+2
View File
@@ -24,6 +24,7 @@ pub mod guard;
pub mod ids;
pub mod face_b;
pub mod menu;
pub mod monitor;
pub mod permission;
pub mod route;
pub mod seed;
@@ -31,6 +32,7 @@ pub mod session;
pub mod state;
pub mod sys;
pub mod system;
pub mod variate_catalog;
/// 测试共享的 pglite 实例(进程级全局单例 ⇒ 所有单测共用,**禁止**各自 `open_temp`)。
#[cfg(test)]
+461
View File
@@ -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<Instant> = 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<Option<[u64; 4]>> = 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<u64> = 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::<u64>().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<String> = 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::<std::collections::HashSet<_>>()
.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<u64> {
let cname = CString::new(name).ok()?;
let mut value: u64 = 0;
let mut size = std::mem::size_of::<u64>();
// 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<String> {
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::<f64>()
.unwrap_or(-1.0);
assert!(
(0.0..=100.0).contains(&rate),
"内存使用率必须是 0..=100:{rate}"
);
assert!(snap["time"].as_i64().unwrap_or(0) > 0, "时间戳必须是真的");
}
}
+109
View File
@@ -168,6 +168,9 @@ pub async fn ensure_base(db: &Db, extra_menus: &[MenuSpec]) -> Result<(), pglite
// 同样是「缺了不报错、下拉全空」⇒ 一起种在这里。
ensure_data_type(db, &now).await?;
ensure_common_fields(db, &now).await?;
// 🔴 `Language` 字典:多语言配置页的**表头**就是它(一个语种一列)。
// 缺了它列表只剩「翻译标记」一列、新建表单也没有语种可填 ⇒ 页面等于废的。
ensure_language_dict(db, &now).await?;
Ok(())
}
@@ -370,6 +373,112 @@ const BUSINESS_TYPES: [(&str, &str, &str); 13] = [
/// `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)",
&params,
)
.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)",
&params,
)
.await?;
}
Ok(())
}
/// 灌 `businessType` 字典(分类 1 行 + 数据 13 行)—— 幂等,按 `f_id` 判存在。
///
/// 🔴 与 [`ensure_business_category`] 同一口径:**不看 `f_delete_mark`**
+39
View File
@@ -94,6 +94,45 @@ impl SessionStore {
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,
}
}
}
#[cfg(test)]
+476
View File
@@ -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#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SUM</span>函数可以获取一组数值的总和</li>
<li>用法:<span class="formula-name">SUM</span>(数值1,数值2,...)</li>
<li>示例:<span class="formula-name">SUM</span>(语文成绩,数学成绩)返回两门课程总分</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"MAX"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">MAX</span>函数可以获取一组数值的最大值</li>
<li>用法:<span class="formula-name">MAX</span>(数字1,数字2,...)</li>
<li>示例:<span class="formula-name">MAX</span>(语文成绩,数学成绩,英语成绩)返回三门课程中的最高分</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"MIN"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">MIN</span>函数可以获取一组数值的最小值</li>
<li>用法:<span class="formula-name">MIN</span>(数字1,数字2,...)</li>
<li>示例:<span class="formula-name">MIN</span>(语文成绩,数学成绩,英语成绩)返回三门课程中的最低分</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"PRODUCT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">PRODUCT</span>函数可以获取一组数值的乘积</li>
<li>用法:<span class="formula-name">PRODUCT</span>(数值1,数值2,...)</li>
<li>示例:<span class="formula-name">PRODUCT</span>(单价,数量)获取总价,即单价和数量的乘积</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"ROUND"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">ROUND</span>函数可以将数字四舍五入到指定的位数</li>
<li>用法:<span class="formula-name">ROUND</span>ROUND(数字,数字位数)</li>
<li>示例:<span class="formula-name">ROUND</span>ROUND(3.1485,2)返回3.15</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"COUNT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">COUNT</span>函数可以获取参数的数量</li>
<li>用法:<span class="formula-name">COUNT</span>(值,值,...)</li>
<li>示例:<span class="formula-name">COUNT</span>(小王,小李)返回2,即人员数量</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"DIVIDE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">DIVIDE</span>函数可以返回数值相除</li>
<li>用法:<span class="formula-name">DIVIDE</span>(被除数,除数)</li>
<li>示例:<span class="formula-name">DIVIDE</span>(总价,单价)获取数量,即总价除单价</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"SUBTRACT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SUBTRACT</span>函数可以返回数值相减</li>
<li>用法:<span class="formula-name">SUBTRACT</span>(被减数,减数)</li>
<li>示例:<span class="formula-name">SUBTRACT</span>(总收入,总支出)返回收支总利润</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"MOD"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">MOD</span>函数可以获取两数相除的余数</li>
<li>用法:<span class="formula-name">MOD</span>(被除数,除数)</li>
<li>示例:<span class="formula-name">MOD</span>(4,3)返回1,也就是4/3的余数</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"ABS"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">ABS</span>函数可以获取一个数的绝对值</li>
<li>用法:<span class="formula-name">ABS</span>(数字)</li>
<li>示例:<span class="formula-name">ABS</span>(-8)可以返回8,也就是-8的绝对值</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"INT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">INT</span>函数可以获取一个数的整数部分</li>
<li>用法:<span class="formula-name">INT</span>(数字)</li>
<li>示例:<span class="formula-name">INT</span>(3.1415)返回3,也就是3.1415的整数部分</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"POWER"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">POWER</span>函数可以获取数字乘幂的结果</li>
<li>用法:<span class="formula-name">POWER</span>(数字,指数)</li>
<li>示例:<span class="formula-name">POWER</span>(3,2)返回9,也就是3的2次方</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"FIXED"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">FIXED</span>函数可将数字舍入到指定的小数位数并输出为文本</li>
<li>用法:<span class="formula-name">FIXED</span>(数字,小数位数)</li>
<li>示例:<span class="formula-name">FIXED</span>(3.1415,2)返回"3.14" </li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"SQRT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SQRT</span>函数可以获取一个数字的正平方根</li>
<li>用法:<span class="formula-name">SQRT</span>(数字)</li>
<li>示例:<span class="formula-name">SQRT</span>(9)返回3,也就是9的正平方根 </li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"LARGE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">LARGE</span>函数可以获取数据集中第k个最大值</li>
<li>用法:<span class="formula-name">LARGE</span>(数组,k)</li>
<li>示例:<span class="formula-name">LARGE</span>(学生成绩.数学成绩,1)返回子表单"学生成绩"中排名第1的"数学成绩"</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"SMALL"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SMALL</span>函数可以返回数据集中第k个最小值</li>
<li>用法:<span class="formula-name">SMALL</span>(数组,k)</li>
<li>示例:<span class="formula-name">SMALL</span>(学生成绩.数学成绩, 1)返回子表单"学生成绩"中排名倒数第一的"数学成绩"</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"AVERAGE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">AVERAGE</span>函数可以获取一组数值的算术平均值</li>
<li>用法:<span class="formula-name">AVERAGE</span>(数字1,数字2,...)</li>
<li>示例:<span class="formula-name">AVERAGE</span>(语文成绩,数学成绩, 英语成绩)返回三门课程的平均分</li>
</ul>"#,
category: r#"MATH"#,
sub_category: r#"数学函数"#,
},
FuncEntry {
name: r#"SPLIT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SPLIT</span>函数可以将文本按指定分割符分割成数组,需配合<span class="formula-name">ARRAYGET</span>来获取指定位置字
符,<span class="formula-name">ARRAYGET</span>(<span class="formula-name">SPLIT</span>(text,text separator),1)</li>
<li>用法:<span class="formula-name">SPLIT</span>(文本,分隔符_文本)</li>
<li>示例:<span class="formula-name">SPLIT</span>("JNPF-快速开发平台","-")返回"JNPF,快速开发平台"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"TEXT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">TEXT</span>函数可以将数字转化成文本</li>
<li>用法:<span class="formula-name">TEXT</span>(数字)</li>
<li>示例:<span class="formula-name">TEXT</span>(3.1415)返回"3.1415"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"TRIM"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">TRIM</span>函数可以删除文本首尾的空格</li>
<li>用法:<span class="formula-name">TRIM</span>(文本)</li>
<li>示例:<span class="formula-name">TRIM</span>(" JNPF ")返回"JNPF"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"UUID"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">UUID</span>函数用于随机码生成</li>
<li>用法:<span class="formula-name">UUID</span>()</li>
<li>示例:<span class="formula-name">CONCATENATE</span>("JNPF-",<span class="formula-name">UUID</span>())生成JNPF-开头的流水号,比如JNPF-FYJQ03VCOA03KCE20YW45E7OIMC390UJU2MK0</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"VALUE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">VALUE</span>函数可以将文本转化为数字</li>
<li>用法:<span class="formula-name">VALUE</span>(文本)</li>
<li>示例:<span class="formula-name">VALUE</span>("3.1415")返回3.1415</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"SEARCH"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">SEARCH</span>函数可以获取文本1在文本2中的开始位置</li>
<li>用法:<span class="formula-name">SEARCH</span>(文本1,文本2)</li>
<li>示例:<span class="formula-name">SEARCH</span>("2026","JNPF2026")返回5</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"RMBFORMAT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">RMBFORMAT</span>函数可以将数字格式化为人民币格式</li>
<li>用法:<span class="formula-name">RMBFORMAT</span>(mumher,[type])</li>
<li>示例:<span class="formula-name">RMBFORMAT</span>(数字输入框)输入123,返回壹佰贰拾参元整</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"REPT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">REPT</span>函数可以将文本重复一定次数</li>
<li>用法:<span class="formula-name">REPT</span>(文本,重复次数)</li>
<li>示例:<span class="formula-name">REPT</span>("JNPF", 3)返回"JNPFJNPFJNPF"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"REPLACE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">REPLACE</span>函数可以根据指定的字符数,将部分文本替换为不同的文本</li>
<li>用法:<span class="formula-name">REPLACE</span>(文本,开始位置,替换长度,新文本)</li>
<li>示例:<span class="formula-name">REPLACE</span>("JNPF快速开发平台",5,10,"数字化平台")返回"JNPF数字化平台</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"PINYINHEADCHAR"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">PINYINHEADCHAR</span>函数可以将字符串中的每个字的首字母以大写形式拼接返回</li>
<li>用法:<span class="formula-name">PINYINHEADCHAR</span>(文本)</li>
<li>示例:<span class="formula-name">PINYINHEADCHAR</span>("JNPF快速开发平台")
// 返回"JNPFKSKFPT"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"MID"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">MID</span>函数返回文本中从指定位置开始的指定数目的字符</li>
<li>用法:<span class="formula-name">MID</span>(文本,开始位置_数字,指定数目)</li>
<li>示例:<span class="formula-name">MID</span>("JNPF快速开发平台",5,6)返回"快速开发平台"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"UPPER"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">UPPER</span>函数可以将一个文本中的所有小写字母转换为大写字母</li>
<li>用法:<span class="formula-name">UPPER</span>(文本)</li>
<li>示例:<span class="formula-name">UPPER</span>("jnpf")返回"JNPF"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"LOWER"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">LOWER</span>函数可以将一个文本中的所有大写字母转换为小写字母</li>
<li>用法:<span class="formula-name">LOWER</span>(文本)</li>
<li>示例:<span class="formula-name">LOWER</span>("JNPF")返回"jnpf"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"LEN"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">LEN</span>函数可以获取文本中的字符个数</li>
<li>用法:<span class="formula-name">LEN</span>(文本)</li>
<li>示例:<span class="formula-name">LEN</span>("JNPF快速开发平台")返回10,因为这句诗中有10个字符</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"RIGHT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">RIGHT</span>函数可以获取由给定文本右端指定数量的字符构成的文本值</li>
<li>用法:<span class="formula-name">RIGHT</span>(文本,文本长度)</li>
<li>示例:<span class="formula-name">RIGHT</span>("JNPF快速开发平台",4)返回"开发平台",也就是"JNPF快速开发平台"从右往左的前4个字符</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"LEFT"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">LEFT</span>函数可以从一个文本的第一个字符开始返回指定个数的字符</li>
<li>用法:<span class="formula-name">LEFT</span>(文本,文本长度)</li>
<li>示例:<span class="formula-name">LEFT</span>("JNPF快速开发平台",4)返回"JNPF",也就是"JNPF快速开发平台"的从左往右的前4个字符</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"CONCATENATE"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">CONCATENATE</span>函数可以将多个文本合并成一个文本</li>
<li>用法:<span class="formula-name">CONCATENATE</span>(文本1,文本2,...)</li>
<li>示例:<span class="formula-name">CONCATENATE</span>("JNPF","快速开发平台")会返回"JNPF快速开发平台"</li>
</ul>"#,
category: r#"TEXT"#,
sub_category: r#"文本函数"#,
},
FuncEntry {
name: r#"ARRAYGET"#,
description: r#"<ul class="formula-desc-wrapper">
<li><span class="formula-name">ARRAYGET</span>函数用于返回数据集中第k个值</li>
<li>用法:<span class="formula-name">ARRAYGET</span>(array, k)</li>
<li>示例:<span class="formula-name">ARRAYGET</span>(<span class="formula-name">SPLIT</span>("JNPF-应用定制工具","-"),1)返回JNPF</li>
</ul>"#,
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"#,
},
];
+106
View File
@@ -1178,6 +1178,112 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
.merge(modules::router())
// ---- 业务包的路由(面 B 官方形状)由**业务包自带** ⇒ 按声明生成 ----
//
// ---- 系统服务族(批次 15):多语言 / 套件 / 缓存 / 任务调度 / IM / 常用菜单 ----
// 🔴 同一个 path 的多个方法合并进**一行** `.route()`(`get(a).post(b)`)——
// 两条独立声明也能跑,但会让静态扫描器把后半段漏掉(详见批次 14 的教训)。
// ⚠️ `/api/system/BaseLang/LangJson` 是**静态段**,matchit 里优先于 `{id}`
// ⇒ 两条同时存在不会互相抢(与 `/Log/deleteLoginLog` 同理)。
.route(
"/api/system/BaseLang",
get(face_b::base_lang_list).post(face_b::base_lang_create),
)
.route(
"/api/system/BaseLang/TemplateDownload",
get(face_b::base_lang_template_download),
)
.route(
"/api/system/BaseLang/ImportData",
post(face_b::base_lang_import_data),
)
.route(
"/api/system/BaseLang/{id}",
get(face_b::base_lang_info)
.put(face_b::base_lang_update)
.delete(face_b::base_lang_delete),
)
// ---- 表单套件(官方 `VisualKitController`,前缀 `Kit`)----
.route(
"/api/system/Kit",
get(face_b::kit_list).post(face_b::kit_create),
)
.route("/api/system/Kit/Selector", get(face_b::kit_selector))
.route(
"/api/system/Kit/{id}",
get(face_b::kit_info)
.put(face_b::kit_update)
.delete(face_b::kit_delete),
)
.route("/api/system/Kit/{id}/Actions/Copy", post(face_b::kit_copy))
.route(
"/api/system/Kit/{id}/Actions/Export",
get(face_b::kit_export),
)
// ---- 缓存管理(本仓 = 内存会话表,见 face_b 的 CacheManage 段说明)----
.route("/api/system/CacheManage", get(face_b::cache_manage_list))
.route(
"/api/system/CacheManage/Actions/ClearAll",
post(face_b::cache_manage_clear_all),
)
.route(
"/api/system/CacheManage/{name}",
get(face_b::cache_manage_info).delete(face_b::cache_manage_delete),
)
// ---- 任务调度(官方 `TimeTaskController`,无 `/api/system` 前缀)----
.route(
"/api/scheduletask",
get(face_b::task_list).post(face_b::task_create),
)
.route("/api/scheduletask/TaskMethods", get(face_b::task_methods))
.route("/api/scheduletask/Info/{id}", get(face_b::task_info))
.route(
"/api/scheduletask/{id}",
put(face_b::task_update).delete(face_b::task_delete),
)
.route(
"/api/scheduletask/{id}/TaskLog",
get(face_b::task_log_list),
)
// ---- IM 会话(官方 `ImReplyController`)----
.route("/api/message/imreply", get(face_b::im_reply_list))
.route(
"/api/message/imreply/deleteChatRecord/{id}",
delete(face_b::im_reply_delete_chat),
)
.route(
"/api/message/imreply/relocation/{id}",
delete(face_b::im_reply_relocation),
)
// ---- 常用(收藏)菜单(官方 `ModuleDataController`)----
.route("/api/system/MenuData", get(face_b::menu_data_list))
.route(
"/api/system/MenuData/{id}",
post(face_b::menu_data_create).delete(face_b::menu_data_delete),
)
// ---- 公式目录(补 Variate 的三条;数据源是生成物 `variate_catalog.rs`)----
.route(
"/api/system/Variate/sysvariate",
get(face_b::variate_sys_variate),
)
.route(
"/api/system/Variate/sysfunctree",
get(face_b::variate_sys_func_tree),
)
.route(
"/api/system/Variate/{type}/sysfunc",
get(face_b::variate_sys_func),
)
// ---- 系统监控 / 我的应用 ----
.route("/api/system/Monitor", get(face_b::monitor))
.route("/api/system/HomeData/mySystem", get(face_b::home_my_system))
// ---- 三处 `Actions/Export`:本仓无文件服务 ⇒ 明确拒绝(不返假 url)----
.route(
"/api/system/System/{id}/Actions/Export",
get(face_b::system_export),
)
.route(
"/api/system/Tag/{id}/Actions/Export",
get(face_b::tag_export),
)
// 🔴 **批次 12 交付物 ①**:业务包声明 `PackRoute`(纯数据)⇒
// 装配根按声明 + spec 生成真正的 axum 路由 ⇒ **平台层零改动**。
// 业务包**不需要**依赖 axum(AR2 / AR8 钉死)。
+946
View File
@@ -0,0 +1,946 @@
//! 批次 15(**系统服务族**)集成测试:
//! `BaseLang`(7) + `Kit`(8) + `CacheManage`(4) + `scheduletask`(7) + `imreply`(3)
//! + `MenuData`(3) + `Variate`(3) + `Monitor`(1) + `HomeData/mySystem`(1) + 三处导出(3)
//! = 39 条端点(另 2 条畸形路径的真实端点早已存在,不在此列),8 张表。
//!
//! 🔴 **钉住的契约点**:
//! ① 多语言是**一行一语种 + `f_group_id` 聚组**:列表按组出一行、`tableHead` 给列定义;
//! `id` 是 **groupId** 不是行 id(前端拿它做详情/更新/删除的键)。
//! ② 套件的 `category` 与批次 14 的控件映射同一个坑:`GET /Kit` 给**分类名称**,
//! `GET /Kit/{id}` 给**分类 id**(编辑表单的 Select 绑的是 id)。
//! ③ 缓存管理在本仓 = **内存会话表**:`name` 形如 `lite:session:<账号>`,
//! 删除**真的**把人踢下线(后续请求 `code=602`),`ClearAll` 保留当前会话。
//! ④ 任务调度**只登记不执行**:`runCount` / `lastRunTime` 恒为表里的真实值(0 / null),
//! `startTime` / `endTime` 是真从 `executeContent` 里提出来的。
//! ⑤ 收藏菜单的判重口径是 `(菜单 id, 我)`;重复收藏必须**明确失败**(不是幂等成功)。
//! ⑥ 公式目录 3 条的数据源是**生成物** `variate_catalog.rs`(35 函数 / 18 变量 /
//! 11 分类),`sysfunctree` 要**排除 `ALL`** 分类。
//! ⑦ 监控是本机**真实**指标(内存/磁盘非零)—— 不是占位 0。
//! ⑧ 三处 `Actions/Export` 一律**明确业务失败**:本仓没有文件服务,
//! 返假 url 会让前端 `downloadByUrl(undefined)` 静默失败(比报错更难查)。
//!
//! 🔴 pglite-rs 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
//! 断言一律按 id / 计数定位,不依赖「列表里只有我造的那几条」。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::bootstrap::ensure_base;
use ssw_platform::platform::config::Config;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::SessionStore;
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::sync::{Mutex, OnceCell};
static DB: OnceCell<Db> = OnceCell::const_new();
static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> Value {
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
serde_json::from_str(body.trim()).unwrap_or(Value::Null)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port))
.await
.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream
.write_all(req.as_bytes())
.await
.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(
std::time::Duration::from_secs(15),
stream.read_to_end(&mut buf),
)
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON");
json["data"]["token"]
.as_str()
.expect("登录必须返回 token")
.to_string()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from(
"/tmp/ssw-platform-batch15-it",
))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 起服务 + 登录,返回 (port, token)。
async fn boot() -> (u16, String) {
let (port, token, _state) = boot_with_state().await;
(port, token)
}
/// 同上,但把 `AppState` 也交出去 —— 白盒测试要往会话表里塞**别的账号**的会话。
async fn boot_with_state() -> (u16, String, AppState) {
let state = new_state(db().await);
let port = serve(state.clone()).await;
let token = login(port).await;
(port, token, state)
}
/// 取单值。`value` 为空 ⇒ **不带参数**(SQL 里就不该有 `$1`)。
async fn scalar(sql: &str, value: &str) -> String {
let owned = value.to_string();
let rows = if value.is_empty() {
Db::query_json_params(db().await, sql, &[]).await
} else {
Db::query_json_params(db().await, sql, &[&owned]).await
}
.expect("查询失败");
rows.first()
.and_then(|row| row.as_object())
.and_then(|obj| obj.values().next())
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
}
// ---------------------------------------------------------------- 多语言(BaseLang)
/// ① 列表按**组**出行 + `tableHead` = `code` + 每个语种一列;详情回 `map`;
/// 更新能删掉不给的语种;`enCode` 重复必须失败。
#[tokio::test]
async fn base_lang_is_grouped_by_en_code_and_head_follows_dictionary() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 建一条:两个语种都有值
let res = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.key","type":0,"map":{"zh-CN":"批十五","en-US":"Batch15"}}"#),
)
.await;
assert_eq!(res["code"], 200, "新建翻译必须成功: {res}");
let group_id = res["data"]["id"].as_str().expect("必须回 groupId").to_string();
// 列表:按组出行,`id` 是 groupId,两个语种各占一列
let list = call(port, "GET", "/api/system/BaseLang?keyword=it.batch15", &token, None).await;
assert_eq!(list["code"], 200);
let rows = list["data"]["list"].as_array().expect("必须有 list");
let mine = rows
.iter()
.find(|row| row["id"] == json!(group_id))
.unwrap_or_else(|| panic!("列表里必须按 groupId 出现: {list}"));
assert_eq!(mine["zh-CN"], "批十五", "语种文本必须落在语种列上: {mine}");
assert_eq!(mine["en-US"], "Batch15");
assert_eq!(mine["typeName"], "客户端", "type=0 ⇒ 客户端");
// 表头 = code + 字典里的两个语种(种子来自官方初始库)
let head = list["data"]["tableHead"].as_array().expect("必须有 tableHead");
let props: Vec<&str> = head.iter().filter_map(|h| h["prop"].as_str()).collect();
assert!(props.contains(&"code"), "表头必须有翻译标记列: {props:?}");
assert!(props.contains(&"zh-CN"), "表头必须有 zh-CN 列: {props:?}");
assert!(props.contains(&"en-US"), "表头必须有 en-US 列: {props:?}");
// 详情:`map` 是「语种 -> 文本」
let info = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["enCode"], "it.batch15.key");
assert_eq!(info["data"]["map"]["zh-CN"], "批十五");
assert_eq!(info["data"]["type"], 0);
// 同 enCode 再建一次 ⇒ 必须失败(否则同义标记会有两组)
let dup = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.key","type":0,"map":{"zh-CN":"重复"}}"#),
)
.await;
assert_eq!(dup["code"], 400, "重复翻译标记必须失败: {dup}");
assert_eq!(dup["data"], Value::Null);
// 更新:只给 zh-CN ⇒ en-US 那一行要被删掉
let upd = call(
port,
"PUT",
&format!("/api/system/BaseLang/{group_id}"),
&token,
Some(r#"{"enCode":"it.batch15.key","type":1,"map":{"zh-CN":"批十五改"}}"#),
)
.await;
assert_eq!(upd["code"], 200, "更新必须成功: {upd}");
let info2 = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(info2["data"]["map"]["zh-CN"], "批十五改");
assert!(
info2["data"]["map"].get("en-US").is_none(),
"没给的语种必须被删掉: {info2}"
);
assert_eq!(info2["data"]["type"], 1, "type 要跟着改(服务端)");
// 删除后详情必须 400(不是返回空壳)
let del = call(
port,
"DELETE",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200);
let gone = call(
port,
"GET",
&format!("/api/system/BaseLang/{group_id}"),
&token,
None,
)
.await;
assert_eq!(gone["code"], 400, "删掉后详情必须明确失败: {gone}");
}
/// 空 `map` 必须被拒(官方 `SYS052`)—— 否则会建出「有标记没翻译」的空组。
#[tokio::test]
async fn base_lang_rejects_empty_language_map() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(
port,
"POST",
"/api/system/BaseLang",
&token,
Some(r#"{"enCode":"it.batch15.empty","type":0,"map":{"zh-CN":" "}}"#),
)
.await;
assert_eq!(res["code"], 400, "全空白的翻译必须失败: {res}");
}
// ---------------------------------------------------------------- 表单套件(Kit)
/// ② 列表 `category` = 名称,详情 = **id**;复制加 `.副本` 后缀;`Selector` 按分类成树。
#[tokio::test]
async fn kit_list_shows_category_name_but_info_returns_id() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 拿一个真实的业务分类(字典 `businessType` 的某一行)
let category_id = scalar(
"SELECT d.f_id AS \"id\" FROM base_dictionary_data d \
JOIN base_dictionary_type t ON t.f_id = d.f_dictionary_type_id \
WHERE t.f_en_code = 'businessType' ORDER BY d.f_sort_code ASC LIMIT 1",
"",
)
.await;
assert!(!category_id.is_empty(), "businessType 字典必须有数据");
let category_name = scalar(
"SELECT f_full_name AS \"name\" FROM base_dictionary_data WHERE f_id = $1::text",
&category_id,
)
.await;
let created = call(
port,
"POST",
"/api/system/Kit",
&token,
Some(&format!(
r#"{{"fullName":"IT套件","enCode":"it_kit_15","category":"{category_id}","icon":"icon-ym icon-ym-app","formData":"{{\"a\":1}}","enabledMark":1}}"#
)),
)
.await;
assert_eq!(created["code"], 200, "新建套件必须成功: {created}");
let kit_id = created["data"]["id"].as_str().expect("必须回 id").to_string();
let list = call(port, "GET", "/api/system/Kit?keyword=IT套件", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须分页");
let row = rows
.iter()
.find(|r| r["id"] == json!(kit_id))
.unwrap_or_else(|| panic!("列表里必须有刚建的套件: {list}"));
assert_eq!(
row["category"], category_name,
"列表的 category 必须是**分类名称**(不是 id): {row}"
);
assert!(
row.get("formData").is_none(),
"列表不该带 formData(只有详情带): {row}"
);
let info = call(
port,
"GET",
&format!("/api/system/Kit/{kit_id}"),
&token,
None,
)
.await;
assert_eq!(
info["data"]["category"], category_id,
"详情的 category 必须是**真 id**(编辑表单要它): {info}"
);
assert_eq!(info["data"]["formData"], "{\"a\":1}");
// 复制:名称加 `.副本` + 5 位后缀
let copied = call(
port,
"POST",
&format!("/api/system/Kit/{kit_id}/Actions/Copy"),
&token,
None,
)
.await;
assert_eq!(copied["code"], 200, "复制必须成功: {copied}");
let copy_name = scalar(
"SELECT f_full_name AS \"n\" FROM base_visual_kit WHERE f_id = $1::text",
copied["data"]["id"].as_str().unwrap_or_default(),
)
.await;
assert!(
copy_name.starts_with("IT套件.副本") && copy_name.len() > "IT套件.副本".len(),
"副本名必须是 `原名.副本xxxxx`:{copy_name}"
);
// Selector:父节点是分类,子节点是套件
let selector = call(port, "GET", "/api/system/Kit/Selector", &token, None).await;
let roots = selector["data"].as_array().expect("Selector 必须是裸数组");
let parent = roots
.iter()
.find(|node| node["id"] == json!(category_id))
.unwrap_or_else(|| panic!("Selector 必须按分类分组: {selector}"));
assert_eq!(parent["hasChildren"], true);
let children = parent["children"].as_array().expect("分类下必须有子节点");
assert!(
children.iter().any(|c| c["id"] == json!(kit_id)),
"套件必须挂在自己分类下面: {parent}"
);
// 编码查重(同 enCode 再来一个必须失败)
let dup = call(
port,
"POST",
"/api/system/Kit",
&token,
Some(&format!(
r#"{{"fullName":"IT套件2","enCode":"it_kit_15","category":"{category_id}","icon":"x"}}"#
)),
)
.await;
assert_eq!(dup["code"], 400, "套件编码重复必须失败: {dup}");
}
// ---------------------------------------------------------------- 缓存管理(CacheManage)
/// ③ 缓存 = 内存会话:列得出、删得掉(**真的**踢下线)、`ClearAll` 保留当前会话。
#[tokio::test]
async fn cache_manage_lists_sessions_and_delete_really_revokes() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let list = call(port, "GET", "/api/system/CacheManage", &token, None).await;
assert_eq!(list["code"], 200, "缓存列表必须成功: {list}");
let rows = list["data"]["list"].as_array().expect("必须分页");
let mine = rows
.iter()
.find(|r| r["name"] == "lite:session:admin")
.unwrap_or_else(|| panic!("在线会话必须出现在缓存列表里: {list}"));
assert!(
mine["cacheSize"].as_i64().unwrap_or(0) > 0,
"缓存大小必须是真实字节数: {mine}"
);
assert_eq!(mine["overdueTime"], Value::Null, "会话不过期 ⇒ null");
// 详情:`value` 是 JSON 字符串(官方 `JSON.toJSONString`)
let info = call(
port,
"GET",
"/api/system/CacheManage/lite:session:admin",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "缓存详情必须成功: {info}");
let value: Value = serde_json::from_str(info["data"]["value"].as_str().unwrap_or_default())
.expect("value 必须是 JSON 字符串");
assert_eq!(value["account"], "admin");
assert!(
!info["data"]["value"]
.as_str()
.unwrap_or_default()
.contains(&token),
"🔴 详情里绝不能出现 token 本身"
);
// 删掉 admin 的会话 ⇒ 同一个 token 立刻失效(602)
let del = call(
port,
"DELETE",
"/api/system/CacheManage/lite:session:admin",
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删除缓存必须成功: {del}");
assert!(
del["data"]["removed"].as_i64().unwrap_or(0) >= 1,
"至少要删掉一条会话: {del}"
);
let after = call(port, "GET", "/api/system/BaseLang", &token, None).await;
assert_eq!(
after["code"], 602,
"会话被清掉后必须掉线(602),不是继续放行: {after}"
);
}
/// ③ `ClearAll` 保留当前操作者的会话(对齐官方「跳过 token 前缀的键」)。
#[tokio::test]
async fn cache_manage_clear_all_keeps_operator_session() {
let _guard = LOCK.lock().await;
let (port, token, state) = boot_with_state().await;
// 白盒塞一条**别的账号**的会话:`ClearAll` 要清它、但不能清操作者自己。
let outsider = state.sessions.issue("it-batch15-outsider", "uid-outsider", 0);
let cleared = call(
port,
"POST",
"/api/system/CacheManage/Actions/ClearAll",
&token,
None,
)
.await;
assert_eq!(cleared["code"], 200, "清空缓存必须成功: {cleared}");
assert!(
cleared["data"]["removed"].as_i64().unwrap_or(0) >= 1,
"至少清掉 outsider 那一条: {cleared}"
);
let mine = call(port, "GET", "/api/system/BaseLang", &token, None).await;
assert_eq!(mine["code"], 200, "操作者自己不能被踢下线: {mine}");
let other = call(port, "GET", "/api/system/BaseLang", &outsider, None).await;
assert_eq!(other["code"], 602, "别的账号的会话必须被清掉: {other}");
}
// ---------------------------------------------------------------- 任务调度(scheduletask)
/// ④ 只登记不执行:`runCount=0`、`lastRunTime=null`、`startTime` 从 `executeContent` 提出。
#[tokio::test]
async fn scheduled_task_registers_without_pretending_to_run() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let created = call(
port,
"POST",
"/api/scheduletask",
&token,
Some(
r#"{"fullName":"IT任务","enCode":"it_task_15","executeType":1,"enabledMark":1,
"executeContent":{"cron":"0 0 1 * * ?","startTime":1700000000000,"endTime":1800000000000,"interfaceId":"x"}}"#,
),
)
.await;
assert_eq!(created["code"], 200, "新建任务必须成功: {created}");
let task_id = created["data"]["id"].as_str().expect("必须回 id").to_string();
let list = call(port, "GET", "/api/scheduletask?keyword=it_task_15", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须分页");
let row = rows
.iter()
.find(|r| r["id"] == json!(task_id))
.unwrap_or_else(|| panic!("列表里必须有刚建的任务: {list}"));
assert_eq!(row["runCount"], 0, "没有调度器 ⇒ 执行次数恒 0: {row}");
assert_eq!(
row["lastRunTime"],
Value::Null,
"没跑过就不能编一个最后执行时间: {row}"
);
assert_eq!(row["startTime"], 1700000000000_i64, "startTime 要从 executeContent 提上来: {row}");
assert_eq!(row["endTime"], 1800000000000_i64);
assert_eq!(row["executeContent"]["cron"], "0 0 1 * * ?");
// 详情:`executeContent` 是**对象**(表单要 `.cron` 这么绑)
let info = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(info["data"]["executeContent"]["cron"], "0 0 1 * * ?");
assert_eq!(info["data"]["enCode"], "it_task_15");
// 日志:没有执行就没有日志(空列表,不是报错)
let logs = call(
port,
"GET",
&format!("/api/scheduletask/{task_id}/TaskLog"),
&token,
None,
)
.await;
assert_eq!(logs["code"], 200, "任务日志必须能查: {logs}");
assert_eq!(
logs["data"]["list"].as_array().map(Vec::len),
Some(0),
"没执行过就不该有日志: {logs}"
);
// `TaskMethods`:没有执行器 ⇒ 空清单(返错会让新建表单整体红条)
let methods = call(port, "GET", "/api/scheduletask/TaskMethods", &token, None).await;
assert_eq!(methods["code"], 200, "TaskMethods 必须成功: {methods}");
assert_eq!(methods["data"]["list"].as_array().map(Vec::len), Some(0));
// 编码查重
let dup = call(
port,
"POST",
"/api/scheduletask",
&token,
Some(r#"{"fullName":"IT任务2","enCode":"it_task_15"}"#),
)
.await;
assert_eq!(dup["code"], 400, "任务编码重复必须失败: {dup}");
// 改 → 删
let upd = call(
port,
"PUT",
&format!("/api/scheduletask/{task_id}"),
&token,
Some(r#"{"fullName":"IT任务改","enabledMark":0}"#),
)
.await;
assert_eq!(upd["code"], 200, "更新必须成功: {upd}");
let after = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(after["data"]["fullName"], "IT任务改");
assert_eq!(after["data"]["enabledMark"], 0);
assert_eq!(
after["data"]["executeContent"]["cron"], "0 0 1 * * ?",
"没改 executeContent ⇒ 原值不能丢"
);
let del = call(
port,
"DELETE",
&format!("/api/scheduletask/{task_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删除必须成功: {del}");
let gone = call(
port,
"GET",
&format!("/api/scheduletask/Info/{task_id}"),
&token,
None,
)
.await;
assert_eq!(gone["code"], 400, "删掉后详情必须明确失败: {gone}");
}
// ---------------------------------------------------------------- 常用菜单(MenuData)
/// ⑤ 收藏 → 列表可见;重复收藏**明确失败**;取消收藏后列表里消失。
#[tokio::test]
async fn menu_data_favorite_is_user_scoped_and_not_idempotent() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let menu_id = scalar(
"SELECT f_id AS \"id\" FROM base_module WHERE f_en_code = 'permission.user' LIMIT 1",
"",
)
.await;
assert!(!menu_id.is_empty(), "种子菜单 permission.user 必须存在");
let created = call(
port,
"POST",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(created["code"], 200, "收藏必须成功: {created}");
let list = call(port, "GET", "/api/system/MenuData", &token, None).await;
let rows = list["data"]["list"].as_array().expect("必须是 {list}");
let row = rows
.iter()
.find(|r| r["id"] == json!(menu_id))
.unwrap_or_else(|| panic!("收藏的菜单必须在列表里: {list}"));
assert_eq!(row["enCode"], "permission.user");
assert!(
row["systemCode"].as_str().unwrap_or_default().len() > 0,
"systemCode 要从 base_system 带出来: {row}"
);
let dup = call(
port,
"POST",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(dup["code"], 400, "重复收藏必须明确失败: {dup}");
let del = call(
port,
"DELETE",
&format!("/api/system/MenuData/{menu_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "取消收藏必须成功: {del}");
let after = call(port, "GET", "/api/system/MenuData", &token, None).await;
assert!(
!after["data"]["list"]
.as_array()
.map(|rows| rows.iter().any(|r| r["id"] == json!(menu_id)))
.unwrap_or(false),
"取消收藏后不该再出现: {after}"
);
// 不存在的菜单 ⇒ 400(不是静默插入一条指向空菜单的收藏)
let ghost = call(
port,
"POST",
"/api/system/MenuData/not-a-menu",
&token,
None,
)
.await;
assert_eq!(ghost["code"], 400, "收藏不存在的菜单必须失败: {ghost}");
}
// ---------------------------------------------------------------- 公式目录(Variate 补 3 条)
/// ⑥ 18 条系统变量 / 按分类取函数 / 函数树排除 `ALL`。
#[tokio::test]
async fn variate_catalog_serves_functions_and_system_variates() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let variates = call(port, "GET", "/api/system/Variate/sysvariate", &token, None).await;
assert_eq!(variates["code"], 200);
let items = variates["data"]["list"].as_array().expect("必须是 {list}");
assert_eq!(items.len(), 18, "官方 `SystemVariateEnum` 是 18 条: {items:?}");
assert!(
items.iter().any(|v| v["field"] == "@userId"),
"必须含 @userId"
);
// 按分类取函数:`type` 与 `?category=` 都认
let math = call(
port,
"GET",
"/api/system/Variate/MATH/sysfunc?category=MATH",
&token,
None,
)
.await;
let funcs = math["data"].as_array().expect("sysfunc 的 data 是**裸数组**");
assert!(!funcs.is_empty(), "数学函数不该是空的: {math}");
assert!(
funcs.iter().all(|f| f["subCategory"] == "数学函数"),
"同一个分类下的函数 subCategory 必须一致: {funcs:?}"
);
assert!(
funcs.iter().any(|f| f["field"] == "SUM"),
"数学函数里必须有 SUM"
);
// 未知分类 ⇒ 空数组(不是报错)
let unknown = call(port, "GET", "/api/system/Variate/NOPE/sysfunc", &token, None).await;
assert_eq!(unknown["code"], 200);
assert_eq!(unknown["data"].as_array().map(Vec::len), Some(0));
// 函数树:父节点是分类(**不含 ALL**),子节点是函数
let tree = call(port, "GET", "/api/system/Variate/sysfunctree", &token, None).await;
let roots = tree["data"]["list"].as_array().expect("必须是 {list}");
assert!(!roots.is_empty(), "函数树不该是空的: {tree}");
assert!(
!roots.iter().any(|node| node["field"] == "ALL"),
"`ALL` 不是真分类,必须被排除: {tree}"
);
let root = &roots[0];
assert_eq!(root["parentId"], "0");
assert_eq!(root["hasChildren"], true);
let children = root["children"].as_array().expect("父节点必须有 children");
assert!(!children.is_empty());
assert_eq!(
children[0]["parentId"], root["id"],
"子节点的 parentId 必须指回父节点 id"
);
assert_eq!(
children[0]["expression"], children[0]["field"],
"函数的 expression 就是函数名"
);
}
// ---------------------------------------------------------------- 监控 / 我的应用 / 导出
/// ⑦ 监控是**真实**指标:内存与磁盘非零、比例在 0..=100。
#[tokio::test]
async fn monitor_reports_real_host_metrics() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/system/Monitor", &token, None).await;
assert_eq!(res["code"], 200, "监控必须成功: {res}");
let data = &res["data"];
assert_ne!(
data["memory"]["total"], "0 B",
"内存总量必须是真值(占位 0 视为失败): {data}"
);
assert_ne!(
data["disk"]["total"], "0 B",
"磁盘总量必须是真值: {data}"
);
let rate = data["memory"]["usageRate"]
.as_str()
.unwrap_or_default()
.parse::<f64>()
.expect("usageRate 必须是两位小数字符串");
assert!((0.0..=100.0).contains(&rate), "使用率必须在 0..=100: {rate}");
assert!(
data["cpu"]["used"].is_string(),
"CPU 使用率必须是字符串(前端按 `'0.00'` 判零): {data}"
);
assert!(
data["time"].as_i64().unwrap_or(0) > 0,
"时间戳必须是真的: {data}"
);
}
/// ⑨ 我的应用 = 授权应用(排除主系统),`data` 是裸数组。
#[tokio::test]
async fn home_my_system_excludes_main_system() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
let res = call(port, "GET", "/api/system/HomeData/mySystem", &token, None).await;
assert_eq!(res["code"], 200, "我的应用必须成功: {res}");
let list = res["data"].as_array().expect("data 必须是**裸数组**");
assert!(!list.is_empty(), "种子里有 app-b ⇒ 至少一个非主系统: {res}");
assert!(
list.iter().all(|s| s["isTop"].is_boolean()),
"每一项都要有 isTop(前端置顶排序用): {list:?}"
);
}
/// ⑧ 三处 `Actions/Export` 一律明确业务失败(本仓无文件服务)。
#[tokio::test]
async fn export_endpoints_refuse_instead_of_returning_a_fake_url() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
for path in [
"/api/system/Kit/any-id/Actions/Export",
"/api/system/System/any-id/Actions/Export",
"/api/system/Tag/any-id/Actions/Export",
] {
let res = call(port, "GET", path, &token, None).await;
assert_eq!(res["code"], 400, "{path} 必须明确失败: {res}");
assert_eq!(res["data"], Value::Null, "{path} 不能返假 url: {res}");
assert!(
res["msg"].as_str().unwrap_or_default().contains("文件服务"),
"{path} 的失败原因必须是「没有文件服务」: {res}"
);
}
}
// ---------------------------------------------------------------- IM 会话(imreply)
/// ⑥ 会话列表的未读数 / 最新消息都从 `base_im_content` **真算**;
/// 删聊天记录只删双方之间的消息,移除会话只动 `base_im_reply`。
#[tokio::test]
async fn im_reply_derives_unread_and_latest_from_content() {
let _guard = LOCK.lock().await;
let (port, token) = boot().await;
// 造数据:admin ↔ 另一个用户的两条消息(一条未读)
// 🔴 种子库只有 `admin` 一个用户,会话列表要 `JOIN base_user` 才出对方名字 ⇒
// 必须自己补一个**启用未删除**的对方,否则列表里根本不会出现这条会话。
// 全文件共用同一个临时库 ⇒ 用固定 id + `ON CONFLICT DO NOTHING` 保证可重跑。
let admin_id = scalar(
"SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1",
"",
)
.await;
Db::exec_params(
db().await,
"INSERT INTO base_user (f_id, f_account, f_real_name, f_enabled_mark, \
f_delete_mark, f_tenant_id, f_creator_time) \
VALUES ('it-batch15-peer', 'itpeer', '对话对端', 1, 0, '0', now()) \
ON CONFLICT (f_id, f_tenant_id) DO NOTHING",
&[],
)
.await
.expect("造第二个用户失败");
let peer_id = scalar(
"SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'itpeer' LIMIT 1",
"",
)
.await;
assert!(
!admin_id.is_empty() && !peer_id.is_empty(),
"至少要两个用户(admin={admin_id}, peer={peer_id})"
);
for sql in [
format!(
"INSERT INTO base_im_reply (f_id, f_user_id, f_receive_user_id, f_receive_time, \
f_delete_mark, f_tenant_id, f_creator_time) \
VALUES ('it-im-reply-1', '{admin_id}', '{peer_id}', now(), 0, '0', now())"
),
format!(
"INSERT INTO base_im_content (f_id, f_send_user_id, f_receive_user_id, f_content, \
f_content_type, f_send_time, f_delete_mark, f_tenant_id) \
VALUES ('it-im-content-1', '{peer_id}', '{admin_id}', '你好', 'text', now(), 0, '0')"
),
] {
Db::exec_params(db().await, &sql, &[]).await.expect("造 IM 数据失败");
}
let res = call(port, "GET", "/api/message/imreply", &token, None).await;
assert_eq!(res["code"], 200, "会话列表必须成功: {res}");
let rows = res["data"]["list"].as_array().expect("必须是 {list}");
let conv = rows
.iter()
.find(|r| r["id"] == json!(peer_id))
.unwrap_or_else(|| panic!("必须出现与 peer 的会话: {res}"));
assert_eq!(conv["unreadMessage"], 1, "未读数要从 content 真算: {conv}");
assert_eq!(conv["latestMessage"], "你好");
// 删聊天记录:只删两人之间的消息
let del = call(
port,
"DELETE",
&format!("/api/message/imreply/deleteChatRecord/{peer_id}"),
&token,
None,
)
.await;
assert_eq!(del["code"], 200, "删聊天记录必须成功: {del}");
let after = call(port, "GET", "/api/message/imreply", &token, None).await;
let conv2 = after["data"]["list"]
.as_array()
.and_then(|rows| rows.iter().find(|r| r["id"] == json!(peer_id)).cloned())
.expect("会话本身还在(只删了消息)");
assert_eq!(conv2["unreadMessage"], 0, "消息删了未读就该归零: {conv2}");
// 移除会话:只动 base_im_reply
let relocated = call(
port,
"DELETE",
&format!("/api/message/imreply/relocation/{peer_id}"),
&token,
None,
)
.await;
assert_eq!(relocated["code"], 200, "移除会话必须成功: {relocated}");
let gone = call(port, "GET", "/api/message/imreply", &token, None).await;
assert!(
!gone["data"]["list"]
.as_array()
.map(|rows| rows.iter().any(|r| r["id"] == json!(peer_id)))
.unwrap_or(false),
"移除后不该再出现: {gone}"
);
}