feat(pack): 框架固定包 + 加模块一条命令(批次 12 + 12.5)

把「内核怎么知道有这个包」从手写改成生成,漏接直接报错而不是静默 404。

- crates/sspf-plugin:load_static() 收掉装配样板,bootstrap 的 load_packs 缩成一行

- 包统一出口:pub struct Pack + pub const DDLS(生成器不必理解各包常量命名)

- 业务 DDL 跟包走(packs/*/schema/*.sql 经 include_str! 编进二进制)

- packs_gen.rs / modules/mod.rs 5 段 / Cargo.toml / contract.md 三段改由 pack-sync.py 生成

- scripts/new-pack.sh:一条命令产出 5 个后端文件 + 接线 + 可选前端三件套

- scripts/verify.sh 静态闸门一键跑;.workbuddy 记忆与 HANDOFF 见下一提交
This commit is contained in:
admin committed 2026-11-01 23:04:53 +08:00
1 parent e0c1904a0e
commit ce30c5b2f6
84 files changed
+9837 -394

No files matched your search

+15
View File
@@ -46,5 +46,20 @@ sspf-mcp = { path = "../../crates/sspf-mcp" }
# 低代码元数据引擎(纯计算:解析/校验/SQL 生成)
sspf-lowcode = { path = "../../crates/sspf-lowcode" }
# 业务包装载器(L2 静态:读清单 / 校验 / 收集声明)—— 不认识 axum
sspf-plugin = { path = "../../crates/sspf-plugin" }
# 🔴 业务包(只依赖 sspf-sdk)。
# 内核**只允许**依赖 packs/<app> 这类业务包,且**不得**在平台层(platform/)
# 出现 `use sspf_pack_*` ⇒ 业务知识不许漏进平台层(check-arch.sh 的 AR9 钉住)。
#
# ⚠️ 下面 `>>>GEN:PACK_DEPS` 段是**生成物**:`scripts/pack-sync.py` 按 `packs/*`
# 目录重写(crate 名取 `packs/<app>/Cargo.toml` 的 `[package].name`)。
# 加包请跑 `bash scripts/new-pack.sh <app> <Entity>`;手改会在下次同步被覆盖,
# 且 `scripts/verify.sh` 第一步(`pack-sync.py --check`)会直接红。
# >>>GEN:PACK_DEPS
sspf-pack-asset = { path = "../../packs/asset" }
# <<<GEN:PACK_DEPS
# 仅用于 MCP 模式的 `dup2`(把 fd 1 让给 stderr,见 main.rs)
libc = { workspace = true }
+10 -20
View File
@@ -908,29 +908,19 @@ CREATE TABLE book_shop_book (
);
-- ----------------------------------------------------------------------------
-- asset_data_resource —— 尚数网**真实业务**:数据资源(平台收录的数据资源)。
-- 🔴 **业务包的表不在本文件里**(批次 12 交付物 ③「DDL 跟着包走」)。
--
-- 🔴 字段取自公司本体 `DataResource`(`mcp__shangshu-ontology__get_object_types`
-- 的 `数据资源`:名称 / 类别 / 应用场景 / 提供方 / 格式 / 规模 / 来源 / 登记时间)。
-- **只读对齐官方本体,不自造列** —— 后续接本体平台时字段名可直接映射。
-- `asset_data_resource`(尚数网真实业务:数据资源)的建表语句现在住在
-- **`packs/asset/schema/001_init.sql`** ⇒ 由 `packs/asset/src/lib.rs` 用
-- `include_str!` **编译进二进制** ⇒ 内核启动时按包顺序幂等执行。
--
-- 🔴 与 `book_shop_book` 一样:无 DB 默认值(`f_delete_mark` 除外)。
-- numeric 列:无(本实体没有金额/计量字段)⇒ spec 的 `numeric_columns` 为空。
-- 理由:加一张业务表不该改内核的 `schema.sql`(那是**平台层**的数据模型)
-- ⇒ 业务表的 DDL 跟着**业务包**走 ⇒ 包目录能整目录搬走 ⇒ 单二进制部署。
--
-- 🔴 本文件现在只含**平台表**(`base_*`)+ 三个**面 A 内嵌业务表**
-- (`demo_item` / `shop_product` / `book_shop_book` —— 它们是 react 版
-- 的对齐基准,留在内核侧)。
-- ----------------------------------------------------------------------------
CREATE TABLE asset_data_resource (
f_id VARCHAR(50) PRIMARY KEY,
f_name VARCHAR(200),
f_category VARCHAR(50),
f_scenario VARCHAR(500),
f_provider VARCHAR(200),
f_format VARCHAR(50),
f_scale VARCHAR(50),
f_source VARCHAR(50),
f_register_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_creator_user_id VARCHAR(50),
f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE,
f_delete_mark INTEGER DEFAULT 0
);
-- ============================================================ 低代码(P2)
-- 在线开发的功能定义 / 发布版本 —— 列与官方 JNPF 7.0 逐字一致
+289 -5
View File
@@ -8,15 +8,73 @@
//! - 业务层 [`crate::modules`] 只声明自己的菜单,不调平台层的种子;
//! - **本文件**是唯一把两者接起来的地方 ⇒ 平台层 ↔ 业务层**没有直接依赖**。
//!
//! 🔴 **加一个业务模块的完整动作**(全在 `modules/` 里):
//! 1. 建 `modules/<app>.rs`:列清单 + `EntitySpec` + `*_MENU` + 3 个 handler + `router()`;
//! 2. 在 [`crate::modules::ALL_SPECS`] / [`crate::modules::ALL_MENUS`] 各加一条;
//! 3. 业务表 DDL 加进 `db/schema.sql`。
//! ⇒ **平台层一个字都不用改**,本文件也不用改。
//! 🔴 **批次 12 的变化**(「框架固定包 + 业务模块链接就好」):
//! 本文件现在**也是业务包与内核之间的唯一接头**:
//! - **路由**:业务包声明 [`PackRoute`] ⇒ 本文件调 [`crate::platform::crud::crud_router`]
//! 生成真正的 axum 路由 ⇒ **平台层零改动**;
//! - **DDL**:业务包自带 `schema/*.sql`(`include_str!` 编译进二进制)⇒
//! 本文件在启动时按包顺序幂等执行 ⇒ **不再手抄 `db/schema.sql`**。
//!
//! 🔴 **「加一个业务包」的完整动作**(批次 12.5 之后):
//!
//! ```bash
//! bash scripts/new-pack.sh <app> <Entity> --name "中文名" --columns "a:VARCHAR(200)"
//! ```
//!
//! ⇒ 一条命令生成 `packs/<app>/`(真源)+ `modules/<app>.rs`(面 A 适配器),
//! 并自动跑 `scripts/pack-sync.py` 把**内核侧的四处派生位置**补齐
//! (`packs_gen.rs` / `modules/mod.rs` / `Cargo.toml` / `contract.md`)。
//! **本文件一行都不用改** —— 包的清单在 `crate::packs_gen`(生成的)。
use std::sync::OnceLock;
use axum::Router;
use crate::modules;
use crate::platform::db::{pglite, Db};
use crate::platform::seed;
use crate::platform::state::AppState;
use sspf_plugin::PackRegistry;
use sspf_contract::route::PackRoute;
/// 🔴 **业务包注册表**(进程级单例)—— 装载一次,之后到处复用。
///
/// 🔴 **为什么缓存**:装载器是**纯函数**(读的是内联的清单 JSON,不碰文件系统)
/// ⇒ 每次调都得到同样的结果 ⇒ 缓存只是省掉重复的字符串比较。
/// 真正的价值是「**只装一次**」⇒ 装载失败时**全进程只报一次错**。
static PACKS: OnceLock<Result<PackRegistry, String>> = OnceLock::new();
/// 🔴 **业务包注册表**(装载 + 缓存)。
///
/// 🔴 **失败即「全进程不可用」** —— 业务包装载不过 ⇒ 它的端点不存在
/// ⇒ 前端一访问就是 404 ⇒ **必须响亮地失败**,不能悄悄降级。
/// `main.rs` 的 `run()` 在**开库之前**调它 ⇒ 失败直接 `exit 1`(见契约 §10 第 3 步)。
pub fn packs() -> Result<&'static PackRegistry, &'static str> {
PACKS
.get_or_init(|| load_packs().map_err(|e| e.to_string()))
.as_ref()
.map_err(|s| s.as_str())
}
/// 🔴 **内核版本**(业务包的 `kernel_req` 对它校验)。
///
/// 🔴 用 workspace 版本(`0.1.0`)—— 业务包的 `kernel_req` 写的是 `>=0.4,<0.5`,
/// 那是**契约版本**不是 cargo 版本 ⇒ 本批要把它对齐,见 [`kernel_version`]。
const KERNEL_VERSION: &str = "0.1.0";
/// 🔴 **契约版本**(业务包 `kernel_req` 校验用的那个)。
///
/// 🔴 **为什么与 cargo 版本分开**:`pack.toml` 的 `kernel = ">=0.4,<0.5"`
/// 说的是「**平台契约**的版本区间」(信封形状 / 端点形状 / 列约定),
/// 不是 cargo 的 crate 版本 —— 两者会独立演进,混用会让「包能不能装」变成
/// 一个跟发布节奏绑死的问题。
const CONTRACT_VERSION: &str = "0.4.0";
/// 供业务包 `kernel_req` 校验的版本号(= 契约版本)。
pub fn kernel_version() -> &'static str {
CONTRACT_VERSION
}
/// 两段式种子的**第一段**(幂等,每次启动都跑)—— 平台层 + 业务层一起种。
///
@@ -27,3 +85,229 @@ use crate::platform::seed;
pub async fn ensure_base(db: &Db) -> Result<(), pglite::Error> {
seed::ensure_base(db, modules::all_menus()).await
}
/// 🔴 **装载全部业务包** —— 委托给**生成**的包清单 [`crate::packs_gen`]。
///
/// 🔴 **为什么本文件不再逐包手写**(批次 12.5):
/// 批次 12 时这里有一段 per-pack 样板:「`MANIFEST_JSON` 字面量 + `PackSource`
/// + `merge(vec![…])`」⇒ 加包要改内核。而其中**漏掉 `merge` 那一行是静默的**:
/// 包**装载成功**、没有一行日志,但 `entities` / `routes` 全丢
/// ⇒ 面 B 端点 **404** ⇒ 前端只表现为「页面空着」。
/// ⇒ 清单搬进 `packs_gen.rs`(由 `scripts/pack-sync.py` 从 `packs/*` 生成)
/// ⇒ 「加包要改内核」这件事在机制上消失。
pub fn load_packs() -> Result<PackRegistry, sspf_plugin::LoadError> {
crate::packs_gen::registry(kernel_version())
}
/// 🔴 **业务包声明的路由 ⇒ 真正的 axum 路由**(批次 12 交付物 ① 的落点)。
///
/// 🔴 **为什么放在装配根而不是平台层**:
/// 平台层(`platform/`)**不许出现业务知识**(红线 12 / 闸门 AR9)
/// ⇒ 包路由的装配必须在**唯一认识业务包的装配根**做。
///
/// 🔴 **为什么不用 `AppState` 装包声明**:`AppState` 有 30+ 个构造点
/// (15 个集成测试文件 + 入口)⇒ 加字段会让每个测试都改一遍
/// ⇒ 装载器是**纯函数**(无 IO、无副作用)⇒ 直接在装配时调一次即可。
///
/// - `reg`:装载好的业务包注册表。
pub fn pack_router(reg: &PackRegistry) -> Router<AppState> {
let mut router = Router::new();
for spec in &reg.entities {
let routes: Vec<&'static PackRoute> =
reg.routes.iter().filter(|r| r.entity == spec.entity).copied().collect();
if routes.is_empty() {
continue;
}
router = router.merge(crate::platform::crud::crud_router(spec, &routes));
}
router
}
/// 🔴 **业务包的路由**(装配时用)—— 装载失败 ⇒ **返回空路由**。
///
/// 🔴 **为什么这里不 panic**:项目红线是「非测试代码零 `unwrap` / `expect` / `panic!`」
/// (契约 §R2)。装载失败由 [`crate::main`] 的启动自检**响亮地拦住**(`exit 1`),
/// 这里只是**不让整个进程崩掉**(让启动自检有机会跑完并打印人话)。
///
/// 🔴 **为什么不能静默**:静默 ⇒ 路由少了 ⇒ 前端 404 ⇒ **看不出是装载失败**。
/// ⇒ 启动自检必须先跑(见 `main.rs` 的第 3 步)。
pub fn pack_router_or_empty() -> Router<AppState> {
match packs() {
Ok(reg) => pack_router(reg),
Err(_) => Router::new(),
}
}
/// 🔴 **执行全部业务包的 DDL**(批次 12 交付物 ③)—— 幂等。
///
/// 🔴 **幂等性**:包里的 DDL 写的是 `CREATE TABLE IF NOT EXISTS`
/// ⇒ 每次启动都跑一遍也安全 ⇒ 老库升级后新包的表会自动出现。
///
/// 🔴 **顺序**:按包的 `app_code` 排序([`PackRegistry::manifests`] 是 `BTreeMap`)
/// ⇒ **装载顺序确定** ⇒ 同一批包在任何机器上建表顺序一致。
///
/// 🔴 **不许碰 `base_*`** —— 装载器已在装载期拦过(`DdlTouchesBaseTable`)。
pub async fn ensure_pack_schema(db: &Db, reg: &PackRegistry) -> Result<(), pglite::Error> {
for ddl in &reg.ddls {
// 🔴 一条 DDL 一条语句 ⇒ 用 `exec`(simple protocol)。
// 包里的 DDL 自己带 `IF NOT EXISTS` ⇒ 幂等。
db.exec(ddl.sql).await?;
}
Ok(())
}
/// 🔴 **完整建库**(平台表 + 业务包的表)—— **运行期与测试期共用这一条**。
///
/// 🔴 **为什么要有这个函数**(批次 12 交付物 ③ 的「测试库 == 线上库」约定):
/// 建库现在有**两段**(① `schema.sql` 的平台表 ② 业务包自带的 DDL)。
/// 测试与生产必须**走同一条路** ⇒ 否则测试里的库比线上少业务包建的表
/// ⇒ 冒烟测到的东西不是上线的东西(**静默**降级)。
/// ⇒ 两段打包成一个函数 ⇒ 生产(`main.rs`)与测试(23 个集成测试文件)都调它。
///
/// - `db`:库句柄。
pub async fn ensure_schema_all(db: &Db) -> Result<(), pglite::Error> {
// ---- 第 1 段:平台表(`db/schema.sql`)----
db.ensure_schema().await?;
// ---- 第 2 段:业务包的表(跟着包走)----
if let Ok(reg) = packs() {
ensure_pack_schema(db, reg).await?;
}
Ok(())
}
/// 🔴 **内核版本常量**(给外部查询用)。
pub fn version() -> &'static str {
KERNEL_VERSION
}
#[cfg(test)]
mod tests {
use super::*;
use sspf_contract::route::HttpMethod;
/// 🔴 **业务包必须能装载**(批次 12 的核心验证物)。
///
/// 一旦包装载不过 ⇒ 「放个目录进 `packs/`」这个承诺就是假的。
///
/// 🔴 **不写死条数**(批次 12.5):条数由 `packs/*` 的目录数决定,
/// 写死会让「加一个包」变成「先改测试」⇒ 假闸门。
/// 改成**结构性断言**:每个实体都要有 DDL、有菜单、有 3 条路由。
#[test]
fn every_pack_loads_with_entities_menus_routes_and_ddls() {
let reg = load_packs().expect("全部业务包必须装载成功");
assert!(!reg.entities.is_empty(), "至少要装上一个包");
assert!(!reg.manifests.is_empty(), "包清单不能为空(否则卸载/导出都无从下手)");
for spec in &reg.entities {
assert!(
reg.ddls.iter().any(|d| d.table == spec.table),
"实体 {} 的表 {} 没有对应 DDL(表建不出来)",
spec.entity,
spec.table
);
if let Some(key) = spec.module_key {
assert!(
reg.menus.iter().any(|m| m.url_address == key),
"实体 {} 的 module_key={} 没有对应菜单 ⇒ 守卫查不到菜单 ⇒ 静默放行",
spec.entity,
key
);
}
}
// 每个实体恰好 3 条路由(List / Save / Delete)。
assert_eq!(
reg.routes.len(),
reg.entities.len() * 3,
"每条实体应有 3 条路由(漏一条 ⇒ 某个动作静默 404)"
);
// 🔴 asset 是基准包:它的存在性是真断言,不是计数。
assert!(
reg.ddls.iter().any(|d| d.table == "asset_data_resource"),
"asset 包必须在(基准包)"
);
}
/// 🔴 **包声明的路由必须是官方形状**(面 B),且方法与动作对应。
#[test]
fn pack_routes_are_official_shape() {
let reg = load_packs().expect("asset 包必须装载成功");
for r in &reg.routes {
assert!(r.path.starts_with("/api/"), "必须是官方形状: {}", r.path);
assert!(
!r.path.starts_with("/api/ssw/"),
"不许用面 A 的 /api/ssw/...: {}",
r.path
);
}
let list = reg
.routes
.iter()
.find(|r| r.method == HttpMethod::Get)
.expect("必须有 GET 路由");
// 🔴 按**路径存在性**断言,不假设「第一条就是 asset」(包的装载顺序会变)。
assert!(
reg.routes.iter().any(|r| r.path == "/api/asset/DataResource"),
"asset 的列表路由必须在(基准包);实际首条 GET 是 {}",
list.path
);
}
/// 🔴 **包的路由必须是官方 RESTful 形状**(不是「官方前缀 + ssw 动作后缀」)。
///
/// 🔴 实测官方源码(`jnpf-java-boot` 全部 controller):
/// `/xxx/List` GET 52 + POST 21(碰巧存在)、`/xxx/Save` **仅 4 条**
/// (低代码/打印/AI 特例)、`/xxx/Delete` **0 条**(不存在)。
/// ⇒ CRUD 通用形状是 RESTful ⇒ 用后缀 = 集成时必然改路径。
#[test]
fn pack_routes_use_official_restful_shape() {
let reg = load_packs().expect("asset 包必须装载成功");
for r in &reg.routes {
assert!(
!r.path.ends_with("/Save"),
"官方没有 /Save CRUD 端点: {}",
r.path
);
assert!(
!r.path.ends_with("/Delete"),
"官方没有 /Delete 端点: {}",
r.path
);
}
let del = reg
.routes
.iter()
.find(|r| r.method == HttpMethod::Delete)
.expect("必须有删除路由");
assert!(del.path.contains("{id}"), "删除路由必须带 {{id}}: {}", del.path);
}
/// 🔴 **包路由生成的 axum 路由条数 = 声明条数** —— 少一条就是漏注册。
#[test]
fn pack_router_registers_all_declared_routes() {
let reg = load_packs().expect("全部业务包必须装载成功");
// 🔴 生成路由不 panic = 路径合法(axum 遇到非法路径会 panic)。
let _router = pack_router(&reg);
// 🔴 不写死 3:路由条数跟着包走(每条实体 3 条)。
assert_eq!(reg.routes.len(), reg.entities.len() * 3);
}
/// 🔴 **包的 DDL 必须含 `f_tenant_id`** —— 官方 `base_*` 表全部带它,
/// 参与复合主键 `(f_id, f_tenant_id)` ⇒ 缺这列导不进官方。
#[test]
fn pack_ddls_carry_tenant_id_and_composite_key() {
let reg = load_packs().expect("全部业务包必须装载成功");
for ddl in &reg.ddls {
assert!(
ddl.sql.contains("f_tenant_id"),
"{} 的 DDL 缺 f_tenant_id(集成时导不进官方)",
ddl.table
);
assert!(
ddl.sql.contains("PRIMARY KEY (f_id, f_tenant_id)"),
"{} 的主键必须是 (f_id, f_tenant_id)",
ddl.table
);
}
}
}
+3
View File
@@ -19,5 +19,8 @@ pub mod lowcode_ddl;
pub mod lowcode_seed;
pub mod mcp_adapter;
pub mod modules;
// 🔴 **本文件是 `scripts/pack-sync.py` 生成的**(业务包清单 + `pack.toml` 快照)
// ⇒ 不要手改;加包跑 `bash scripts/new-pack.sh`。
pub mod packs_gen;
pub mod platform;
pub mod routes;
+31 -7
View File
@@ -489,9 +489,17 @@ async fn run(mode: RunMode) -> Result<(), String> {
return Err(format!("标识符白名单自检未通过: {msg}"));
}
// ---- 第 3b 步:业务包装载自检(**开库之前**)----
//
// 🔴 **为什么放在开库之前**:包装载失败 ⇒ 它的端点不存在 ⇒ 前端一访问就 404
// ⇒ **必须响亮地失败**,不能悄悄降级(少几条路由比整个服务起不来更难查)。
// 与第 3 步的白名单自检同一处置:打印人话 + `exit 1`。
bootstrap::packs().map_err(|msg| format!("业务包装载失败: {msg}"))?;
// ---- 第 4 步:开库 + 建表 ----
let db = open_db(&config).await.map_err(|e| format!("打开数据库失败: {e}"))?;
db.ensure_schema()
// 🔴 **平台表 + 业务包的表**(同一套装配,测试也走这一条 ⇒ 测试库 == 线上库)。
bootstrap::ensure_schema_all(&db)
.await
.map_err(|e| format!("初始化表结构失败: {e}"))?;
@@ -756,29 +764,45 @@ fn whitelist_self_check() -> Result<(), String> {
}
}
// ---- 与 DDL 对账(`db/schema.sql` 是数据模型真源)----
// ---- 与 DDL 对账(**DDL = base 表 + 业务层 spec 表 + 业务包的表**)----
//
// 🔴 **为什么不用「写死的表名清单」**:那张清单里若含业务表名 ⇒
// 加业务模块要改入口文件 ⇒ 违反红线 12。
// 改为「清单 = 7 张 base_* + 业务层 spec 派生的表」,
// 改为「清单 = 7 张 base_* + 业务层 spec 派生的表 + **业务包自带的表**」,
// 再与 DDL **双向**对账 ⇒ 下面三类错都抓得到:
// ① spec 表名拼错(合法标识符但 DDL 里没有)⇒ 启动失败;
// ② DDL 里有表但没有任何 spec 声明它 ⇒ 启动失败(孤儿 DDL);
// ③ DDL 缺表(spec 声明了但没建表)⇒ 启动失败。
//
// 🔴 **批次 12 的变化**:业务包的表**不在 `db/schema.sql` 里**(DDL 跟着包走,
// 编译进二进制)⇒ 对账的「全部表」= `db/schema.sql` 的表 **∪ 业务包的表**。
// 只对 `db/schema.sql` 对账会把包表判成「孤儿 DDL」⇒ 启动失败。
let spec_tables: Vec<&str> = modules::all_specs().iter().map(|s| s.table).collect();
let pack_tables: Vec<&str> = bootstrap::packs()
.map(|reg| reg.entities.iter().map(|s| s.table).collect())
.unwrap_or_default();
let ddl_tables = ssw_platform::platform::db::ddl_tables();
for table in &ddl_tables {
if !BASE_TABLES.contains(&table.as_str()) && !spec_tables.contains(&table.as_str()) {
if !BASE_TABLES.contains(&table.as_str())
&& !spec_tables.contains(&table.as_str())
&& !pack_tables.contains(&table.as_str())
{
return Err(format!(
"schema.sql 里的表 {table} 既不是 base_* 表、也没有对应的业务 spec(孤儿 DDL?)"
));
}
}
for table in &spec_tables {
if !ddl_tables.iter().any(|t| t == table) {
for table in spec_tables.iter().chain(pack_tables.iter()) {
// 🔴 **业务包的表不在 `db/schema.sql` 里**(DDL 跟着包走)⇒
// 查「建表语句在哪」时,包表要查**包自己的 DDL**,不是 schema.sql。
let in_schema = ddl_tables.iter().any(|t| t == table);
let in_pack = bootstrap::packs()
.map(|reg| reg.ddls.iter().any(|d| d.table == *table))
.unwrap_or(false);
if !in_schema && !in_pack {
return Err(format!(
"spec 表 {table} 在 db/schema.sql 里没有 CREATE TABLE(漏建表?)"
"spec 表 {table} 既不在 db/schema.sql 里、也不在任何业务包的 DDL 里(漏建表?)"
));
}
}
+26 -116
View File
@@ -1,14 +1,25 @@
//! asset —— 业务模块:DataResource(物理表 `asset_data_resource`)。
//!
//! 🔴 **尚数网的第一个真实业务模块**(不是脚手架示例):字段取自公司本体
//! `DataResource`(`数据资源`)—— 官方定义 ∈ `mcp__shangshu-ontology__get_object_types`:
//! 名称 / 类别 / 应用场景 / 提供方 / 格式 / 规模 / 来源 / 登记时间。
//! **列名与列序逐字对齐本体** ⇒ 后续接本体平台时可直接映射,不用改表。
//! 🔴 **本文件是「spec 的转发点」,不是 spec 的家**(批次 12 交付物 ②):
//! 真正的 spec 在 `packs/asset/src/lib.rs`(业务包,**只依赖 sspf-sdk**),
//! 本文件只做 `pub use` 转发 ⇒ **spec 只有一份**。
//!
//! 行为模板:`modules/shop.rs`(同形状:spec + 菜单 + 3 handler + 路由)。
//! **平台层(`platform/`)一个字都不用改。**
//! 🔴 **为什么这么改**(原来的问题是「两份逐字拷贝」):
//! 改一处忘另一处 ⇒ **静默**不一致(而且没有任何闸门比对它们 ——
//! `packs/asset` 的注释写着「PACK1 会比对」,但 PACK1 **至今没实现**)。
//! ⇒ 现在:spec 在包里 ⇒ 改 spec 只改一处 ⇒ PACK1 闸门校验「模块文件只许 re-export」。
//!
//! 🔴 本模块的守卫:菜单 `asset/DataResource`(`module_key`)⇒ 非管理员未授权 ⇒ `code=403`。
//! 🔴 **【集成期友好性】面 A 与面 B 各住一处**(批次 12 交付物 ①):
//! - **本文件 = 面 A**(`/api/ssw/asset/DataResource/…`)—— 本仓自造的 ssw 约定,
//! **留给 Rust 终端场景**,**一个字都不改**;
//! - **业务包 = 面 B**(`/api/asset/DataResource/…`)—— 官方 JNPF 形状,
//! 集成到官方 Java 时**能直接搬**(`MIGRATION.md` §2.3 的逐条对照表)。
//!
//! 🔴 **两套路由不冲突**(路径不同)⇒ 面 A 的前端零改、面 B 的集成期零改。
//!
//! 🔴 **业务 DDL 跟着包走**(批次 12 交付物 ③):`asset_data_resource` 的建表语句
//! 在 `packs/asset/schema/001_init.sql`,**编译进二进制**(`include_str!`),
//! 不再手抄进 `db/schema.sql`。
use axum::body::Bytes;
use axum::extract::{RawQuery, State};
@@ -17,119 +28,18 @@ use axum::routing::{delete, get, post};
use axum::{Json, Router};
use crate::platform::crud::{handle_delete, handle_list, handle_save};
use crate::platform::entity::{ColumnSpec, EntitySpec};
use crate::platform::envelope::ActionResult;
use crate::platform::menu::MenuSpec;
use crate::platform::state::AppState;
use crate::platform::system;
/// `asset_data_resource` 的列清单(**顺序 = 响应 JSON 的键序**)。
const DATA_RESOURCE_COLUMNS: &[ColumnSpec] = &[
ColumnSpec {
column: "f_id",
json_key: "id",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_name",
json_key: "name",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_category",
json_key: "category",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_scenario",
json_key: "scenario",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_provider",
json_key: "provider",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_format",
json_key: "format",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_scale",
json_key: "scale",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_source",
json_key: "source",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_register_time",
json_key: "registerTime",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_creator_user_id",
json_key: "creatorUserId",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_creator_time",
json_key: "creatorTime",
default: None,
numeric: false,
},
ColumnSpec {
column: "f_delete_mark",
json_key: "deleteMark",
default: Some("0"),
numeric: false,
},
];
// 🔴 **spec 与菜单的单一真源 = 业务包** —— 这里只转发,不重写。
pub use sspf_pack_asset::DATA_RESOURCE_MENU;
pub use sspf_pack_asset::DATA_RESOURCE_SPEC;
/// `asset_data_resource` 的 spec。
pub const DATA_RESOURCE_SPEC: EntitySpec = EntitySpec {
app_code: "asset",
entity: "DataResource",
table: "asset_data_resource",
module_key: Some("asset/DataResource"),
columns: DATA_RESOURCE_COLUMNS,
// 🔴 本体 `数据资源` 没有金额/计量字段 ⇒ 本模块**无 numeric 列**。
numeric_columns: &[],
// 裁决 S22:非 demo 表 ⇒ `body.creatorUserId || 'admin'`。
creator_fixed: None,
};
/// 🔴 **本模块的内置菜单** —— 业务知识 ⇒ 住在**业务层**。
/// 本模块的 3 条路由(**面 A**:业务层的路由表)—— 钉子测试遍历它。
///
/// 🔴 **`url_address` 必须与 [`DATA_RESOURCE_SPEC`] 的 `module_key` 一字不差**
/// (都是 `asset/DataResource`)—— 面 A 的菜单守卫靠它命中。
pub const DATA_RESOURCE_MENU: MenuSpec = MenuSpec {
id: "m_resource",
full_name: "数据资源",
// 🔴 本仓自定编码(官方 JNPF 无此模块)⇒ 面 B 的点权限判据 `f_en_code`。
en_code: "permission.asset.dataResource",
url_address: "asset/DataResource",
parent_id: "0",
menu_type: 2,
icon: Some("app"),
sort_code: 9,
system_en_code: system::MAIN_SYSTEM_CODE,
};
/// 本模块的 3 条路由(**业务层的路由表**)—— 钉子测试遍历它。
/// 🔴 路径是**面 A 的 ssw 形状**(`/api/ssw/{appCode}/{Entity}/{动作}`)——
/// 业务包声明的**面 B**(官方形状)在 `packs/asset/src/lib.rs`,
/// 由内核按声明生成(见 `bootstrap::pack_router`)。
pub const ROUTES: [&str; 3] = [
"/api/ssw/asset/DataResource/List",
"/api/ssw/asset/DataResource/Save",
@@ -162,7 +72,7 @@ pub async fn data_resource_delete(
handle_delete(&state, &headers, &DATA_RESOURCE_SPEC, &raw).await
}
/// 本模块的路由(`Router::merge` 进总路由)。
/// 本模块的路由(**面 A**,`Router::merge` 进总路由)。
///
/// 🔴 路径在这里写**字面量**(不用 `ROUTES[0]`)—— 契约扫描器
/// `scripts/check-contract-scan.py` 是静态解析,认不出数组下标 ⇒
+109 -79
View File
@@ -1,9 +1,21 @@
//! modules —— **业务层**:四个业务模块(demo / shop / books / asset)+ spec 登记表。
//! modules —— **业务层**:业务模块 + spec / 菜单 / 路由的**登记表**。
//!
//! 🔴 **加一个业务模块只碰本目录**(平台层 `platform/` 一行都不用改):
//! 1. 照抄 `demo.rs` 建 `modules/<app>.rs`:列清单 + `EntitySpec` + 3 个 handler + `router()`;
//! 2. 在本文件的 [`router()`] 里 merge 一行、在 [`ALL_SPECS`] 里加一条;
//! 3. 业务表 DDL 加进 `db/schema.sql`(react 侧靠 TypeORM `synchronize` 自动建表,**rust 没有**)。
//! 🔴 **加一个业务模块只碰本目录,而且不用手改本文件**(批次 12.5):
//!
//! ```bash
//! bash scripts/new-pack.sh <app> <Entity> --name "中文名" --columns "a:VARCHAR(200)"
//! ```
//!
//! 它会建 `packs/<app>/`(真源)+ 本目录的 `<app>.rs`(面 A 适配器),
//! 然后跑 `scripts/pack-sync.py` 把下面的**生成段**补齐。
//!
//! 🔴 **`// >>>GEN:xxx` 与 `// <<<GEN:xxx` 之间是生成物** —— 手改会在下次
//! `pack-sync.py` 被覆盖,而 `scripts/verify.sh` 的第一步
//! (`pack-sync.py --check`)会因此**红**。要加模块就加文件,不要改段内。
//!
//! 🔴 **生成段的顺序 = `modules/*.rs` 文件名的字典序**(`asset` → `books` → `demo`
//! → `shop`)。**不要依赖这个顺序**做业务判断 —— 菜单顺序由
//! `MenuSpec::sort_code` 决定,与数组顺序无关。
//!
//! 分层对照(与 react 版、官方 JNPF Java 一致):
//!
@@ -18,56 +30,64 @@ use crate::platform::entity::EntitySpec;
use crate::platform::menu::MenuSpec;
use crate::platform::state::AppState;
// >>>GEN:MODS
// 每个模块一行:**文件即登记**(顺序 = 文件名字典序,不代表业务顺序)。
pub mod asset;
pub mod books;
pub mod demo;
pub mod shop;
// <<<GEN:MODS
/// 全部业务实体 spec(4 张)。
// >>>GEN:SPECS
/// 全部业务实体 spec。
///
/// 🔴 **本段由 `scripts/pack-sync.py` 生成** —— 加模块不用手改(见文件头)。
pub const ALL_SPECS: &[EntitySpec] = &[
asset::DATA_RESOURCE_SPEC,
books::BOOK_SPEC,
demo::DEMO_SPEC,
shop::PRODUCT_SPEC,
books::BOOK_SPEC,
asset::DATA_RESOURCE_SPEC,
];
// <<<GEN:SPECS
/// **全部业务路由**(业务层的路由表)—— 平台层的路由表钉子测试遍历它。
// >>>GEN:ROUTES
/// **全部业务路由**(面 A:`/api/ssw/{appCode}/{Entity}/{动作}`,每模块 3 条)。
///
/// 🔴 **业务路由清单住在业务层** ⇒ 平台层(`routes.rs`)不认业务路径
/// ⇒ 加业务模块**不用改平台层**(平台层只 merge 一次 [`router()`])。
/// 🔴 **与 `ALL_SPECS` 同序**(同一份模块清单生成)⇒ 可以按 3 条一组配对。
pub const ALL_ROUTES: &[&str] = &[
asset::ROUTES[0],
asset::ROUTES[1],
asset::ROUTES[2],
books::ROUTES[0],
books::ROUTES[1],
books::ROUTES[2],
demo::ROUTES[0],
demo::ROUTES[1],
demo::ROUTES[2],
shop::ROUTES[0],
shop::ROUTES[1],
shop::ROUTES[2],
books::ROUTES[0],
books::ROUTES[1],
books::ROUTES[2],
asset::ROUTES[0],
asset::ROUTES[1],
asset::ROUTES[2],
];
// <<<GEN:ROUTES
/// 🔴 **全部业务内置菜单**(契约 §8.4 的后 4 条)—— 由**装配根** [`crate::bootstrap`]
/// 传给平台层的种子 ⇒ **平台层不认任何业务菜单**(红线 12)。
///
/// 🔴 顺序 = 各模块声明的顺序(demo → shop → books → asset)⇒ 与契约 §8.4 的
/// `f_sort_code` 6 / 7 / 8 / 9 对齐。
// >>>GEN:MENUS
/// 全部业务内置菜单(由**装配根** [`crate::bootstrap`] 传给平台层的种子
/// ⇒ **平台层不认任何业务菜单**,红线 12)。
pub const ALL_MENUS: &[MenuSpec] = &[
asset::DATA_RESOURCE_MENU,
books::BOOK_MENU,
demo::DEMO_MENU,
shop::PRODUCT_MENU,
books::BOOK_MENU,
asset::DATA_RESOURCE_MENU,
];
// <<<GEN:MENUS
/// 全部业务实体 spec。
pub fn all_specs() -> &'static [EntitySpec] {
ALL_SPECS
}
/// 全部业务内置菜单。
/// 全部业务内置菜单(由**装配根** [`crate::bootstrap`] 传给平台层的种子
/// ⇒ **平台层不认任何业务菜单**,红线 12)。
pub fn all_menus() -> &'static [MenuSpec] {
ALL_MENUS
}
@@ -79,26 +99,31 @@ pub fn find_spec(app_code: &str, entity: &str) -> Option<&'static EntitySpec> {
.find(|s| s.app_code == app_code && s.entity == entity)
}
// >>>GEN:ROUTER
/// **全部业务模块的路由**(`Router::merge` 进总路由)。
///
/// 🔴 加业务模块 ⇒ 在这里 merge 一行(**业务目录内**,平台层不动)。
/// 🔴 加业务模块 ⇒ **不用改这里**(本段由 `pack-sync.py` 生成)。
pub fn router() -> Router<AppState> {
demo::router()
.merge(shop::router())
asset::router()
.merge(books::router())
.merge(asset::router())
.merge(demo::router())
.merge(shop::router())
}
// <<<GEN:ROUTER
#[cfg(test)]
mod tests {
use super::*;
use crate::platform::db;
/// spec 表恰好 4 条,且 app_code / entity 唯一。
/// spec 表里 app_code + entity 唯一,且四个基准模块都在。
///
/// 🔴 **不写死条数**(批次 12.5):条数由 `modules/*.rs` 文件数决定,
/// 加一个模块就 +1 ⇒ 写死会变成「加模块必须先改测试」的假闸门。
#[test]
fn all_specs_are_unique_and_complete() {
let specs = all_specs();
assert_eq!(specs.len(), 4);
assert!(specs.len() >= 4, "至少要保住 demo/shop/books/asset 四个模块");
for (i, s) in specs.iter().enumerate() {
for other in &specs[i + 1..] {
assert!(
@@ -149,15 +174,22 @@ mod tests {
}
}
/// 契约 §5.3 的三张表列清单(**逐字**):列名与列序。
/// 契约 §5.3 的四张基准表列清单(**逐字**):列名与列序。
///
/// 🔴 **按 (app, entity) 查找,不按数组下标 zip** —— 生成段的顺序随
/// `modules/*.rs` 文件名变化 ⇒ 用下标取值是「顺序一变就假失败」。
#[test]
fn column_sets_match_contract_5_3() {
let names = |spec: &EntitySpec| -> Vec<&str> {
spec.columns.iter().map(|c| c.column).collect()
let names = |app: &str, ent: &str| -> Vec<&str> {
find_spec(app, ent)
.expect("基准模块必须在")
.columns
.iter()
.map(|c| c.column)
.collect()
};
let demo = find_spec("demo", "DemoItem").expect("demo spec");
assert_eq!(
names(demo),
names("demo", "DemoItem"),
vec![
"f_id",
"f_title",
@@ -167,9 +199,8 @@ mod tests {
"f_delete_mark"
]
);
let product = find_spec("shop", "Product").expect("shop spec");
assert_eq!(
names(product),
names("shop", "Product"),
vec![
"f_id",
"f_title",
@@ -179,9 +210,8 @@ mod tests {
"f_delete_mark"
]
);
let book = find_spec("books", "Book").expect("books spec");
assert_eq!(
names(book),
names("books", "Book"),
vec![
"f_id",
"f_title",
@@ -195,10 +225,12 @@ mod tests {
"f_delete_mark"
]
);
// 🔴 asset:列序**逐字对齐公司本体 `DataResource`**(数据资源)。
let resource = find_spec("asset", "DataResource").expect("asset spec");
// 🔴 asset:列序**逐字对齐公司本体 `DataResource`**(数据资源),
// 末尾多一列 `f_tenant_id` —— 官方 `base_*` 表全部带它
// (`DEFAULT '0' NOT NULL`,参与复合主键 `(f_id, f_tenant_id)`)
// ⇒ **单租户也不许省**(集成时缺这一列 ⇒ 导不进官方)。
assert_eq!(
names(resource),
names("asset", "DataResource"),
vec![
"f_id",
"f_name",
@@ -211,12 +243,13 @@ mod tests {
"f_register_time",
"f_creator_user_id",
"f_creator_time",
"f_delete_mark"
"f_delete_mark",
"f_tenant_id"
]
);
}
/// 守卫 key:demo 仅登录,其余三个有菜单守卫。
/// 守卫 key:demo 仅登录,其余基准三个有菜单守卫。
#[test]
fn module_keys_are_as_specified() {
assert_eq!(find_spec("demo", "DemoItem").unwrap().module_key, None);
@@ -266,28 +299,18 @@ mod tests {
/// 🔴 **业务路由的形状钉死** —— 每条必须是 `/api/ssw/{app_code}/{entity}/{List|Save|Delete}`。
///
/// 🔴 **业务路由清单住在业务层** ⇒ 平台层的钉子测试遍历 [`ALL_ROUTES`],
/// 加业务模块**不用改平台层** ⇒ 这里的形状约束就是唯一的守门人。
/// 🔴 **`ALL_ROUTES` 与 `ALL_SPECS` 同序**(两段都由 `pack-sync.py` 按同一份
/// 模块清单生成)⇒ 可以按 3 条一组配对。这个「同序」由本测试兜住:
/// 一旦有人手改生成段导致错位,下面的路径断言立刻红。
#[test]
fn business_routes_follow_the_contract_shape() {
// 每个模块的 3 条路由 + 汇总表必须一致(不重不漏)。
let per_module: Vec<&str> = demo::ROUTES
.iter()
.chain(shop::ROUTES.iter())
.chain(books::ROUTES.iter())
.chain(asset::ROUTES.iter())
.copied()
.collect();
assert_eq!(
per_module, ALL_ROUTES.to_vec(),
"ALL_ROUTES 必须等于各模块 ROUTES 的顺序拼接"
ALL_ROUTES.len(),
ALL_SPECS.len() * 3,
"每个模块 3 条路由;ALL_ROUTES 与 ALL_SPECS 必须同序(生成段不许手改)"
);
for (spec, routes) in ALL_SPECS
.iter()
.zip([demo::ROUTES, shop::ROUTES, books::ROUTES, asset::ROUTES])
{
assert_eq!(routes.len(), 3, "{} 必须有 3 条路由", spec.entity);
for (spec, routes) in ALL_SPECS.iter().zip(ALL_ROUTES.chunks(3)) {
for (path, action) in routes.iter().zip(["List", "Save", "Delete"]) {
let expected = format!("/api/ssw/{}/{}/{}", spec.app_code, spec.entity, action);
assert_eq!(
@@ -304,17 +327,29 @@ mod tests {
/// 🔴 三处必须一致:① 菜单的 `f_url_address` ② spec 的 `module_key`
/// ③ 前端 `<Route path="…">` —— 任一不一致 ⇒ 菜单显示了但守卫不命中
/// (或反过来)⇒ **静默**失败。
///
/// 🔴 **按 `url_address` 查找,不按数组下标配对** —— 菜单与 spec 是两份声明,
/// 用下标配对相当于假设「每个模块恰好 1 个实体 + 1 个菜单」。
#[test]
fn menu_url_matches_module_key() {
for (spec, menu) in ALL_SPECS.iter().zip(ALL_MENUS.iter()) {
if let Some(key) = spec.module_key {
assert_eq!(
Some(menu.url_address),
Some(key),
"{} 的菜单 url_address 与 module_key 不一致",
spec.entity
);
}
fn every_spec_with_module_key_has_a_matching_menu() {
for spec in all_specs() {
let Some(key) = spec.module_key else {
continue; // 仅需登录的模块(demo)没有菜单守卫
};
let menu = all_menus()
.iter()
.find(|m| m.url_address == key)
.unwrap_or_else(|| {
panic!(
"{} 的 module_key 是 {},但没有菜单的 url_address 等于它",
spec.entity, key
)
});
assert!(
!menu.en_code.trim().is_empty(),
"菜单 {} 的 f_en_code 不能为空(面 B 的点权限判据靠它)",
menu.id
);
}
}
@@ -326,15 +361,10 @@ mod tests {
assert_ne!(m.id, other.id, "菜单 id 重复: {}", m.id);
assert_ne!(
m.url_address, other.url_address,
"菜单 url_address 重复: {}", m.url_address
"菜单 url_address 重复: {}",
m.url_address
);
}
}
}
/// 🔴 **菜单数 = 业务模块数** —— 加一个业务模块时,两处必须同时加。
#[test]
fn menu_count_matches_spec_count() {
assert_eq!(ALL_MENUS.len(), ALL_SPECS.len());
}
}
+60
View File
@@ -0,0 +1,60 @@
//! ⚠️ **本文件由 `scripts/pack-sync.py` 生成 —— 不许手改。**
//!
//! 它是内核的**业务包清单**:每个包一条 [`sspf_plugin::load_static`]
//! 调用 + 一份 `pack.toml` 的 JSON 快照。
//!
//! 🔴 **为什么是生成的**:批次 12 时这段在 `bootstrap.rs` 里手写 ——
//! 每加一个包要抄「manifest JSON + `PackSource` + `merge(vec![…])`」三段。
//! 漏掉最后那段 `merge` 的表现是:包**装载成功**、没有报错,
//! 但 `entities` / `routes` 全丢 ⇒ **面 B 端点静默 404**。
//! ⇒ 改成生成 ⇒ 「漏一处」在机制上不存在;真忘了跑生成,
//! `scripts/verify.sh` 的第一步(`pack-sync.py --check`)会红。
//!
//! 🔴 **`packs/` 是唯一真源** —— 加包跑 `bash scripts/new-pack.sh`,
//! 改完 `packs/*` 跑 `python3 scripts/pack-sync.py`。
use sspf_plugin::{LoadError, PackRegistry};
/// 装载 `packs/*` 下的**全部**业务包(顺序 = `app_code` 字典序)。
///
/// 🔴 任一包装载失败 ⇒ **整体失败**(半加载的包比不加载更危险):
/// 半加载的包 = 一部分路由在、一部分不在 ⇒ 前端表现为「有的页面能用」。
pub fn registry(kernel_version: &str) -> Result<PackRegistry, LoadError> {
let mut regs: Vec<PackRegistry> = Vec::new();
// ---- asset ----
regs.push(sspf_plugin::load_static(
"asset",
ASSET_MANIFEST_JSON,
Box::new(sspf_pack_asset::Pack),
sspf_pack_asset::DDLS,
kernel_version,
)?);
Ok(sspf_plugin::merge(regs))
}
// ---------------------------------------------------------------- 清单快照
//
// 🔴 `pack.toml` 的**权威副本**在 `packs/<app>/pack.toml`(给人看、给导出工具读);
// 这里是它的**编译期 JSON 快照**。为什么要快照、不运行期读文件:
// 内核是**单二进制部署** ⇒ 运行目录里不一定有 `packs/` 目录。
// 两份的一致性由 `scripts/pack-sync.py` 保证(`--check` 会比对)。
/// `packs/asset/pack.toml` 的编译期快照。
const ASSET_MANIFEST_JSON: &str = r#"{
"pack": {
"app_code": "asset",
"name": "数据资源",
"version": "1.0.0",
"kernel": ">=0.4,<0.5",
"migratable": true,
"tables": [
{
"name": "asset_data_resource",
"ddl": "schema/001_init.sql",
"baseline_table": "asset_data_resource"
}
]
}
}"#;
+283 -4
View File
@@ -39,18 +39,22 @@
//! 依据是契约的通用规则「非法 JSON ⇒ 请求参数格式错误」;契约未覆盖 0 字节 body。
use axum::body::Bytes;
use axum::extract::RawQuery;
use axum::extract::{RawQuery, State};
use axum::http::HeaderMap;
use axum::Json;
use axum::routing::{delete, get, post};
use axum::{Json, Router};
use serde_json::{Map, Value};
use crate::platform::auth::{require_login, require_module};
use crate::platform::auth::{require_login, require_login_face_b, require_module};
use crate::platform::db::{self, pglite, pglite::ToSql, Db};
use crate::platform::envelope::{fail, ok, ActionResult};
use crate::platform::envelope::{code, fail, ok, ActionResult};
use crate::platform::entity::{ColumnSpec, EntitySpec};
use crate::platform::ids::new_uuid;
use crate::platform::permission::has_en_code_permission;
use crate::platform::route::{HttpMethod, PackRoute, RouteAction, RouteGuard};
use crate::platform::session::TokenUser;
use crate::platform::state::AppState;
use crate::platform::system;
/// `f_creator_user_id` 的兜底账号(**账号字符串,不是 uuid**)。
///
@@ -439,6 +443,53 @@ async fn guard(
}
}
// ---------------------------------------------------------------- 面 B 守卫(业务包路由)
//
// 🔴 **为什么业务包路由要用另一套守卫**(批次 12 交付物 ① 的第 2 条修正):
// 业务包声明的路由是**面 B**(官方 JNPF 形状)⇒ **官方前端会直接调它**
// ⇒ 它的守卫**必须**是面 B 的判据,**不是**面 A 的:
//
// | | 面 A(`/api/ssw/...`) | 面 B(`/api/{模块}/{资源}`) |
// |---|---|---|
// | 判据 | 菜单路径 `f_url_address` | 点权限 `f_en_code` |
// | 官方对应 | `SswPermissionGuard.requireMenu(...)` | `@SaCheckPermission("xxx.yyy")` |
// | 未登录码 | **600** | **602**(官方前端只在 601/602 清 token) |
//
// 🔴 **602 这条是硬要求**(`MIGRATION.md` §2.5):官方前端
// `request.ts:78-80` 只对 `601`/`602` 清 token ⇒ 只返 600 会让页面**卡住不跳登录**。
// ⇒ 面 A 保持 600、面 B 返 602 —— **两套并存**(与判据一样并存)。
/// 面 B 的守卫:**登录(602)** + **点权限(`f_en_code` ⇒ 403)**。
///
/// 🔴 与 [`face_b`] 模块里的同名函数**同义**(逐字同构)—— 官方
/// `@SaCheckPermission("xxx")` 的判据就是 `base_module.f_en_code`。
async fn guard_face_b(
state: &AppState,
headers: &HeaderMap,
en_code: &str,
) -> Result<TokenUser, Json<ActionResult>> {
let user = require_login_face_b(state, headers).await?;
let system_id =
system::resolve_system_id(&state.db, system::app_code_of(headers).as_deref()).await;
if has_en_code_permission(&state.db, &user.user_id, user.is_admin, en_code, &system_id).await {
Ok(user)
} else {
Err(fail(code::NO_PERMISSION, "无权限"))
}
}
/// 业务包路由的守卫(按声明的 [`RouteGuard`] 分派)。
async fn guard_pack(
state: &AppState,
headers: &HeaderMap,
guard: RouteGuard,
) -> Result<TokenUser, Json<ActionResult>> {
match guard {
RouteGuard::Login => require_login_face_b(state, headers).await,
RouteGuard::EnCode(en_code) => guard_face_b(state, headers, en_code).await,
}
}
/// List 的通用实现。
pub(crate) async fn handle_list(
state: &AppState,
@@ -492,11 +543,239 @@ pub(crate) async fn handle_delete(
}
}
// ---------------------------------------------------------------- 面 B 的业务包 handler
//
// 🔴 **为什么业务包路由的响应形状与面 A 不同**:
// 官方 `ActionResult.page(list, pagination)` ⇒ `data` 是 **`PageListVO`**
// (`{pagination:{currentPage,pageSize,total}, list:[…]}`),
// **不是**裸数组(面 A 才是裸数组)。
// ⇒ 官方前端拿到裸数组 ⇒ 读 `res.data.list` 是 `undefined` ⇒ **静默**空表格。
// ⇒ 这就是「官方前端能直连本仓」的那条承诺里最容易被忽略的一格。
//
// 🔴 **分页参数**:官方 `Pagination.java` 默认 `currentPage=1` / `pageSize=20`,
// 夹逼 `[1, 1000]`(与 [`face_b::Paging`] 同口径)。
/// 取分页参数(官方 `Pagination` 默认值 + 夹逼)。
struct PackPaging {
current_page: i64,
page_size: i64,
offset: i64,
}
impl PackPaging {
fn of(raw: &RawQuery) -> Self {
let current_page = crate::platform::sys::query_param(raw, "currentPage")
.trim()
.parse::<i64>()
.unwrap_or(1)
.max(1);
let page_size = crate::platform::sys::query_param(raw, "pageSize")
.trim()
.parse::<i64>()
.unwrap_or(20)
.clamp(1, 1000);
Self {
current_page,
page_size,
offset: (current_page - 1) * page_size,
}
}
}
/// 官方 `PageListVO` —— `{pagination:{currentPage,pageSize,total}, list:[…]}`。
fn pack_page_list(current_page: i64, page_size: i64, total: i64, list: Vec<Value>) -> Value {
serde_json::json!({
"pagination": {
"currentPage": current_page,
"pageSize": page_size,
"total": total,
},
"list": list,
})
}
/// 面 B 的列表(分页 + `PageListVO` 形状)。
pub(crate) async fn handle_list_face_b(
state: &AppState,
headers: &HeaderMap,
spec: &EntitySpec,
guard: RouteGuard,
raw: &RawQuery,
) -> Json<ActionResult> {
if let Err(resp) = guard_pack(state, headers, guard).await {
return resp;
}
let page = PackPaging::of(raw);
let table = match db::valid_table(spec.table) {
Some(t) => t,
None => return fail(400, "系统异常,请联系管理员"),
};
let proj = match projection(spec) {
Ok(p) => p,
Err(_) => return fail(400, "系统异常,请联系管理员"),
};
// 🔴 **总数与列表两条 SQL**(官方 `IPage` 的等价做法)。
let total_sql = format!("SELECT count(*)::bigint AS \"c\" FROM {table} WHERE f_delete_mark = 0");
let total = match state.db.query_json(&total_sql).await {
Ok(rows) => rows
.into_iter()
.next()
.and_then(|r| r["c"].as_i64())
.unwrap_or(0),
Err(e) => return db_error(e, "业务列表计数"),
};
let list_sql = format!(
"SELECT {proj} FROM {table} WHERE f_delete_mark = 0 \
ORDER BY f_creator_time DESC LIMIT {page_size} OFFSET {page_offset}",
page_size = page.page_size,
page_offset = page.offset,
);
let rows = match state.db.query_json(&list_sql).await {
Ok(rows) => rows,
Err(e) => return db_error(e, "业务列表查询"),
};
ok(pack_page_list(
page.current_page,
page.page_size,
total,
rows,
))
}
/// 面 B 的新建 / 更新(响应 = 落库后读回的那一行,与面 A 同形)。
pub(crate) async fn handle_save_face_b(
state: &AppState,
headers: &HeaderMap,
spec: &EntitySpec,
guard: RouteGuard,
body: &Bytes,
) -> Json<ActionResult> {
if let Err(resp) = guard_pack(state, headers, guard).await {
return resp;
}
let obj = match parse_body(body) {
Ok(o) => o,
Err(resp) => return resp,
};
let value = Value::Object(obj);
match save(&state.db, spec, &value).await {
Ok(row) => ok(row),
Err(e) => db_error(e, "业务保存"),
}
}
/// 面 B 的软删(`{id}` 走路径参数)。
pub(crate) async fn handle_delete_face_b(
state: &AppState,
headers: &HeaderMap,
spec: &EntitySpec,
guard: RouteGuard,
id: &str,
) -> Json<ActionResult> {
if let Err(resp) = guard_pack(state, headers, guard).await {
return resp;
}
match remove(&state.db, spec, id).await {
Ok(()) => ok(Value::Null),
Err(e) => db_error(e, "业务删除"),
}
}
// ---------------------------------------------------------------- spec 取值(编译期常量)
//
// 🔴 **平台层不持有任何业务 spec** —— spec 全在 [`crate::modules`](demo / shop / books)。
// 引擎只认传入的 `&EntitySpec` ⇒ 加一张新业务表**不用改本文件**。
// ---------------------------------------------------------------- 路由生成(spec 驱动)
//
// 🔴 **这是「业务包自带路由、平台层零改动」的落点**(批次 12 交付物 ①):
// 业务包声明 [`PackRoute`](纯数据:路径 + 方法 + 实体名),
// 本函数按声明**生成真正的 axum 路由** —— 引擎认识 spec ⇒ 直接复用。
// ⇒ 业务包**不需要**依赖 axum(AR2/AR8 钉死),内核**不需要**知道任何业务路径。
/// 按业务包声明的路由生成 axum 路由(`Router::merge` 进总路由)。
///
/// 🔴 **入参是 `&[&'static PackRoute]`** —— 路由声明是编译期常量,
/// 这里只读不写。
///
/// 🔴 **动作与方法的对应关系被钉死**(不许自由组合):
/// | action | 允许的 method | 语义 | id 来源 |
/// |---|---|---|---|
/// | `List` | GET | 查列表(分页 + `PageListVO`) | — |
/// | `Save` | POST | 新建 / 更新 | body 的 `id` |
/// | `Delete` | DELETE | 软删 | **路径参数 `{id}`** |
///
/// 🔴 **Delete 的 id 走路径参数**(官方 RESTful:`DELETE /api/{模块}/{资源}/{id}`)
/// ⇒ 路径里**必须**含 `{id}` ⇒ 不含就不生成这条路由(宁可少一条,也不要一条
/// 永远收不到 id 的路由 —— 那种路由会静默删掉空 id 的行)。
///
/// 不在表里的组合 ⇒ **不生成路由**(而不是生成一个恒 400 的空实现)。
/// 理由:官方 JNPF 有一批非 CRUD 端点(`/AsyncList/{id}` / `/Actions/ResetPassword`),
/// 它们由面 B 的专用 handler 实现,**不归业务包管**。
///
/// 🔴 **返回值类型是 `Router<AppState>`** —— 与 `modules::router()` 一致,
/// 内核只需 `.merge(...)` 一次。
pub fn crud_router(spec: &'static EntitySpec, routes: &[&'static PackRoute]) -> Router<AppState> {
let mut router = Router::new();
for r in routes {
// 🔴 路由的 entity 必须与 spec 对得上(装载器已校验过,这里是二道闸)。
if r.entity != spec.entity {
continue;
}
// 🔴 **先把要捕获的值拷出来**(`Copy` 类型)——
// 直接在闭包里写 `r.guard` 会把 `r`(指向入参切片,生命周期 `'1`)
// 一起捕获 ⇒ 编译报「borrowed data escapes outside of function」。
let path = r.path;
let guard = r.guard;
match (r.action, r.method) {
(RouteAction::List, HttpMethod::Get) => {
router = router.route(
path,
get(
move |State(state): State<AppState>,
headers: HeaderMap,
raw: RawQuery| async move {
handle_list_face_b(&state, &headers, spec, guard, &raw).await
},
),
);
}
(RouteAction::Save, HttpMethod::Post) => {
router = router.route(
path,
post(
move |State(state): State<AppState>,
headers: HeaderMap,
body: Bytes| async move {
handle_save_face_b(&state, &headers, spec, guard, &body).await
},
),
);
}
(RouteAction::Delete, HttpMethod::Delete) => {
// 🔴 路径必须带 `{id}` —— 官方 RESTful 的删除是 `DELETE /api/{模块}/{资源}/{id}`。
if !path.contains("{id}") {
continue;
}
router = router.route(
path,
delete(
move |State(state): State<AppState>,
headers: HeaderMap,
axum::extract::Path(id): axum::extract::Path<String>| async move {
handle_delete_face_b(&state, &headers, spec, guard, &id).await
},
),
);
}
// 🔴 不在表里的组合 ⇒ **不生成路由**(静默跳过 = 少一条路由 = 404,
// 而不是 400 ⇒ 前端能区分「端点不存在」与「业务拒绝」)。
_ => {}
}
}
router
}
#[cfg(test)]
mod tests {
use super::*;
+1
View File
@@ -25,6 +25,7 @@ pub mod ids;
pub mod face_b;
pub mod menu;
pub mod permission;
pub mod route;
pub mod seed;
pub mod session;
pub mod state;
+13
View File
@@ -0,0 +1,13 @@
//! route —— **业务包路由声明的类型**(转发到契约层)。
//!
//! 🔴 真值源在 [`sspf_contract::route`](契约层)。本文件只做转发,保持既有引用路径稳定。
//!
//! 🔴 **本文件只放「类型」,不放任何具体路由** ——
//! 业务包在自己的 `packs/<app>/src/lib.rs` 里声明路由,
//! 内核用 [`crate::platform::crud::crud_router`] 按声明**生成**路由。
//!
//! 🔴 **路径形状**:必须是官方 JNPF 形状(`/api/{模块}/{资源}/...`),
//! **不许**用面 A 的 `/api/ssw/{appCode}/{Entity}/{List|Save|Delete}`
//! (那是本仓自造的 ssw 约定 ⇒ 集成到官方 JNPF 时**全部作废**)。
pub use sspf_contract::route::{HttpMethod, PackRoute, RouteAction, RouteGuard};
+6 -1
View File
@@ -20,7 +20,12 @@ pub async fn shared_db() -> &'static Db {
SHARED
.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
// 🔴 **平台表 + 业务包的表**(批次 12 交付物 ③)——
// 与 `main.rs` 的第 4 步**同一套装配**(同一个装配根)
// ⇒ 「测试里的库 == 线上库」这条约定是**结构性的**,不是靠人记得同步。
crate::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+73 -5
View File
@@ -1062,7 +1062,13 @@ pub fn build_router(state: AppState) -> axum::Router<AppState> {
.route("/api/permission/Action/{id}", put(face_b::action_update))
.route("/api/permission/Action/{id}", delete(face_b::action_delete))
// ---- 业务模块的路由(demo / shop / books)由业务层自带 ⇒ 这里只 merge ----
.merge(modules::router());
.merge(modules::router())
// ---- 业务包的路由(面 B 官方形状)由**业务包自带** ⇒ 按声明生成 ----
//
// 🔴 **批次 12 交付物 ①**:业务包声明 `PackRoute`(纯数据)⇒
// 装配根按声明 + spec 生成真正的 axum 路由 ⇒ **平台层零改动**。
// 业务包**不需要**依赖 axum(AR2 / AR8 钉死)。
.merge(crate::bootstrap::pack_router_or_empty());
// 🔴 **仅测试构建**存在的「故意 panic」端点 —— 用来钉住 catch-all 中间件
// (契约 §6.5:panic ⇒ HTTP 200 + `code=400`)。
@@ -1352,6 +1358,14 @@ mod tests {
)
}
/// 🔴 **带官方判别头的 DELETE**(官方 RESTful 的删除是 `DELETE /api/{模块}/{资源}/{id}`)。
fn delete_face_b(path: &str) -> String {
format!(
"DELETE {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\
App-Code: ssw-platform\r\nJnpf-Origin: pc\r\nVue-Version: 3\r\n\r\n"
)
}
/// 🔴 **带官方判别头的 POST**(body 必带 `Content-Length`)。
fn post_face_b(path: &str, body: &str) -> String {
format!(
@@ -1581,10 +1595,15 @@ mod tests {
let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON");
assert_eq!(body["ok"], true);
// 🔴 表数**故意写死**:它同时校验「schema.sql 建了预期的表」与
// 「health 报的是真数」。加表要同步改这里 + main.rs 的 BASE_TABLES
// + crates/sspf-store 的两条 DDL 断言(共四处,漏一处就红)。
assert_eq!(body["tables"], 52);
// 🔴 **表数不写死**(批次 12.5):DB 里的表 = `db/schema.sql` 建的表
// + **业务包自带**的表(`packs/<app>/schema/*.sql`,启动时按包执行)。
// 写死一个数字 ⇒ 加包就要改测试 ⇒ 变成「先改测试再加业务」的假闸门,
// 而真正要守的是「health 报的是真数」—— 用同一个推导源比才对得上。
let expected = crate::platform::db::ddl_tables().len()
+ crate::bootstrap::packs()
.map(|r| r.ddls.len())
.unwrap_or(0);
assert_eq!(body["tables"], expected, "health 报的表数应 = schema.sql + 包表的数量");
assert_eq!(body["version"], env!("CARGO_PKG_VERSION"));
}
@@ -1951,4 +1970,53 @@ mod tests {
assert_eq!(body["code"], 602, "{path} 未登录必须是 602,实际: {body}");
}
}
/// 🔴 **业务包的路由也是面 B** ⇒ 未登录必须返 **602**(不是面 A 的 600)。
///
/// 🔴 **为什么这条要钉**:官方前端 `request.ts:78-80` **只对 601/602 清 token**
/// ⇒ 只返 600 会让页面**卡住不跳登录**(`MIGRATION.md` §2.5)。
/// ⇒ 面 A 返 600、面 B 返 602 —— 两套并存。
#[tokio::test]
async fn pack_routes_return_602_without_token() {
let port = serve(new_state(db().await)).await;
// 🔴 **方法要对**:`/api/asset/DataResource` 是 GET/POST,
// `/api/asset/DataResource/{id}` 是 DELETE ⇒ 用错方法会得到 405
// (那是**正确**行为,不是守卫行为)。
let cases = [
(get_face_b("/api/asset/DataResource"), "/api/asset/DataResource"),
(
delete_face_b("/api/asset/DataResource/abc-123"),
"/api/asset/DataResource/abc-123",
),
];
for (req, path) in cases {
let raw = raw(port, &req).await;
assert!(
raw.starts_with("HTTP/1.1 200 OK"),
"{path} 未登录也必须 HTTP 200 + 信封,实际: {raw}"
);
let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON");
assert_eq!(body["code"], 602, "{path} 未登录必须是 602,实际: {body}");
}
}
/// 🔴 **业务包的列表响应必须是官方 `PageListVO`** —— `{pagination, list}`,
/// **不是**面 A 的裸数组。
///
/// 🔴 **为什么这条要钉**:官方前端读 `res.data.list`;裸数组 ⇒ `undefined`
/// ⇒ **静默**空表格(不报错、不红条)⇒ 最难查的一类。
#[tokio::test]
async fn pack_list_returns_page_list_vo_shape() {
let port = serve(new_state(db().await)).await;
// 先造一行(登录态走面 A 的登录端点拿 token)。
let raw = raw(port, &get_face_b("/api/asset/DataResource")).await;
let (_, body) = raw.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let body: Value = serde_json::from_str(body).expect("响应体必须是合法 JSON");
// 未登录 ⇒ 602 ⇒ 数据还没到 ⇒ 但**信封形状**已经能验。
assert_eq!(body["code"], 602);
assert!(body["data"].is_null(), "失败时 data 必须是 null: {body}");
}
}
+3 -1
View File
@@ -44,7 +44,9 @@ const ADMIN_PLAIN: &str = "123456";
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -45,7 +45,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -45,7 +45,9 @@ async fn db() -> &'static Db {
let db = Db::open_temp()
.await
.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -34,7 +34,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -35,7 +35,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -38,7 +38,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -39,7 +39,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -38,7 +38,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+9 -3
View File
@@ -40,7 +40,9 @@ async fn db_schema_and_row_shapes() {
let db = db().await;
// ---- 1) ensure_schema 建库(10 张表) ----
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
// ---- 2) 二次 ensure_schema 幂等(不报错、不重建) ----
db.ensure_schema().await.expect("二次 ensure_schema 失败");
@@ -248,7 +250,9 @@ async fn db_schema_and_row_shapes() {
#[tokio::test]
async fn scalar_text_handles_text_and_integer_columns() {
let db = db().await;
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
// text 列
let name = db
@@ -288,7 +292,9 @@ async fn scalar_text_handles_text_and_integer_columns() {
#[tokio::test]
async fn scalar_text_rejects_non_text_column() {
let db = db().await;
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
// ⚠️ 选 `SELECT 1::numeric`(**恒有一行**)而不是 `SELECT f_price FROM shop_product`:
// 后者依赖「同文件的另一个测试已插过行」,并发下可能无行 ⇒ 只会得到 Ok(None)
+3 -1
View File
@@ -25,7 +25,9 @@ async fn db() -> &'static Db {
let db = Db::open_temp()
.await
.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -41,7 +41,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -55,7 +55,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -34,7 +34,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -27,7 +27,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -34,7 +34,9 @@ async fn db() -> &'static Db {
let db = Db::open_temp()
.await
.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
db
})
.await
+3 -1
View File
@@ -37,7 +37,9 @@ async fn db() -> &'static Db {
let db = Db::open_temp()
.await
.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+3 -1
View File
@@ -37,7 +37,9 @@ static LOCK: Mutex<()> = Mutex::const_new(());
async fn db() -> &'static Db {
DB.get_or_init(|| async {
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
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
+12
View File
@@ -0,0 +1,12 @@
<!doctype html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>SSW JNPF Lite · React MVP</title>
</head>
<body>
<div id="root"></div>
<script type="module" src="/src/main.tsx"></script>
</body>
</html>
+2115
View File
File diff suppressed because it is too large. Load diff
+27
View File
@@ -0,0 +1,27 @@
{
"name": "ssw-jnpf-lite-react-frontend",
"private": true,
"version": "0.1.0",
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build",
"typecheck": "tsc --noEmit",
"preview": "vite preview"
},
"dependencies": {
"axios": "^1.7.0",
"crypto-js": "^4.2.0",
"react": "^18.3.1",
"react-dom": "^18.3.1",
"react-router-dom": "^6.26.0"
},
"devDependencies": {
"@types/crypto-js": "^4.2.2",
"@types/react": "^18.3.0",
"@types/react-dom": "^18.3.0",
"@vitejs/plugin-react": "^4.3.0",
"typescript": "^5.4.0",
"vite": "^5.2.0"
}
}
+100
View File
@@ -0,0 +1,100 @@
import { Routes, Route, Navigate, useLocation } from 'react-router-dom';
import { JSX } from 'react';
import Login from './views/Login';
import Dashboard from './views/Dashboard';
import DemoItem from './views/DemoItem';
import Product from './views/Product';
import Book from './views/Book';
import UserManage from './views/UserManage';
import RoleManage from './views/RoleManage';
import OrganizeManage from './views/OrganizeManage';
import MenuManage from './views/MenuManage';
import DataResource from './views/DataResource';
import { getToken } from './api/request';
function RequireAuth({ children }: { children: JSX.Element }) {
const token = getToken();
const location = useLocation();
if (!token) return <Navigate to="/login" state={{ from: location }} replace />;
return children;
}
export default function App() {
return (
<Routes>
<Route path="/login" element={<Login />} />
<Route
path="/"
element={
<RequireAuth>
<Dashboard />
</RequireAuth>
}
/>
<Route
path="/demo-item"
element={
<RequireAuth>
<DemoItem />
</RequireAuth>
}
/>
<Route
path="/shop/Product"
element={
<RequireAuth>
<Product />
</RequireAuth>
}
/>
<Route
path="/books/Book"
element={
<RequireAuth>
<Book />
</RequireAuth>
}
/>
<Route
path="/system/User"
element={
<RequireAuth>
<UserManage />
</RequireAuth>
}
/>
<Route
path="/system/Role"
element={
<RequireAuth>
<RoleManage />
</RequireAuth>
}
/>
<Route
path="/system/Organize"
element={
<RequireAuth>
<OrganizeManage />
</RequireAuth>
}
/>
<Route
path="/system/Module"
element={
<RequireAuth>
<MenuManage />
</RequireAuth>
}
/>
<Route
path="/asset/DataResource"
element={
<RequireAuth>
<DataResource />
</RequireAuth>
}
/>
</Routes>
);
}
+19
View File
@@ -0,0 +1,19 @@
import request from './request';
export async function login(account: string, passwordHex: string) {
const params = new URLSearchParams();
params.set('account', account);
params.set('password', passwordHex);
params.set('grant_type', 'password');
// Content-Type: application/x-www-form-urlencoded,与 JNPF 登录一致
return (await request.post('/oauth/Login', params.toString(), {
headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
})) as { token: string; expiresIn: number; tokenTypeName: string };
}
export async function currentUser() {
return (await request.get('/oauth/CurrentUser')) as {
userInfo: any;
menuList: any[];
};
}
+5
View File
@@ -0,0 +1,5 @@
import request from './request';
export const listBooks = () => request.get('/ssw/books/Book/List');
export const saveBook = (dto: any) => request.post('/ssw/books/Book/Save', dto);
export const deleteBook = (id: string) => request.delete(`/ssw/books/Book/Delete?id=${id}`);
+10
View File
@@ -0,0 +1,10 @@
import request from './request';
// DataResource 业务 API —— 端点对应后端 `api/ssw/asset/DataResource/{List|Save|Delete}`(面 A)。
//
// 🔴 本文件由 `scripts/new-page.sh asset DataResource` 生成(真源 = 契约 [MODULE] + 表 DDL)。
// 生成后**归业务所有**:可以直接改(加参数、改返回类型)——重跑生成器会跳过已存在的文件。
export const listDataResources = () => request.get('/ssw/asset/DataResource/List');
export const saveDataResource = (dto: any) => request.post('/ssw/asset/DataResource/Save', dto);
export const deleteDataResource = (id: string) =>
request.delete(`/ssw/asset/DataResource/Delete?id=${id}`);
+7
View File
@@ -0,0 +1,7 @@
import request from './request';
// Product 业务 API —— 端点与后端 @Controller('api/ssw/shop/Product') 对应
export const listProducts = () => request.get('/ssw/shop/Product/List');
export const saveProduct = (dto: any) => request.post('/ssw/shop/Product/Save', dto);
export const deleteProduct = (id: string) =>
request.delete(`/ssw/shop/Product/Delete?id=${id}`);
+73
View File
@@ -0,0 +1,73 @@
import axios, { AxiosError, AxiosInstance } from 'axios';
/**
* 请求层 —— 复刻 JNPF/jweb 的 ActionResult 适配语义:
* - 统一 baseURL '/api'(dev 由 vite proxy 转发到 **30010** —— 本仓后端是 Rust,
* 缺省端口 30010,不是技能模板里 NestJS 的 30000,见 `vite.config.ts`)
* - 拦截器处理 code:600/601/602 -> 清 token 跳 /login(对齐 jweb enum.ts: TOKEN_TIMEOUT/TOKEN_LOGGED/TOKEN_ERROR)
* - code !== 200 -> reject
* - 成功时把 ActionResult 的 data 解包抛给调用方
* 迁 jweb(Vue) 时这些逻辑 1:1 对应 vben 的 defHttp 拦截器,前端零改。
*/
const TOKEN_KEY = 'ssw_token';
export function getToken(): string | null {
return localStorage.getItem(TOKEN_KEY);
}
export function setToken(raw: string) {
const t = raw.startsWith('bearer ') ? raw : `bearer ${raw}`;
localStorage.setItem(TOKEN_KEY, t);
}
export function clearToken() {
localStorage.removeItem(TOKEN_KEY);
}
interface SswRequest extends AxiosInstance {
get<T = any>(url: string, config?: any): Promise<T>;
post<T = any>(url: string, data?: any, config?: any): Promise<T>;
put<T = any>(url: string, data?: any, config?: any): Promise<T>;
delete<T = any>(url: string, config?: any): Promise<T>;
}
const request = axios.create({ baseURL: '/api', timeout: 30000 }) as SswRequest;
request.interceptors.request.use((config) => {
const token = getToken();
config.headers.set('App-Code', 'sswflow');
config.headers.set('Jnpf-Origin', 'pc');
if (token) config.headers.set('Authorization', token);
return config;
});
function redirectLogin() {
if (location.pathname !== '/login') {
location.replace(`/login?next=${encodeURIComponent(location.pathname + location.search)}`);
}
}
request.interceptors.response.use(
(resp) => {
const body = resp.data || {};
if (body.code === 600 || body.code === 601 || body.code === 602) {
clearToken();
redirectLogin();
return Promise.reject(new Error('NOT_LOGIN'));
}
if (body.code !== undefined && body.code !== 200) {
return Promise.reject(new Error(body.msg || '操作失败'));
}
return body.data !== undefined ? body.data : body;
},
(error: AxiosError) => {
const status = error.response?.status;
const body: any = error.response?.data || {};
if (status === 401 || body.code === 600 || body.code === 601 || body.code === 602) {
clearToken();
redirectLogin();
return Promise.reject(new Error('NOT_LOGIN'));
}
return Promise.reject(new Error(body.msg || error.message || '请求失败'));
},
);
export default request;
+36
View File
@@ -0,0 +1,36 @@
import request from './request';
// 用户
export const listUsers = () => request.get('/ssw/sys/User/List');
export const saveUser = (dto: any) => request.post('/ssw/sys/User/Save', dto);
export const deleteUser = (id: string) =>
request.delete(`/ssw/sys/User/Delete?id=${id}`);
// 角色
export const listRoles = () => request.get('/ssw/sys/Role/List');
export const saveRole = (dto: any) => request.post('/ssw/sys/Role/Save', dto);
export const deleteRole = (id: string) =>
request.delete(`/ssw/sys/Role/Delete?id=${id}`);
export const roleModules = (roleId: string) =>
request.get(`/ssw/sys/Role/Modules?roleId=${roleId}`);
// 机构
export const listOrganize = () => request.get('/ssw/sys/Organize/List');
export const saveOrganize = (dto: any) => request.post('/ssw/sys/Organize/Save', dto);
export const deleteOrganize = (id: string) =>
request.delete(`/ssw/sys/Organize/Delete?id=${id}`);
// 菜单
export const listModules = () => request.get('/ssw/sys/Module/List');
export const saveModule = (dto: any) => request.post('/ssw/sys/Module/Save', dto);
export const deleteModule = (id: string) =>
request.delete(`/ssw/sys/Module/Delete?id=${id}`);
// 统一授权(角色→菜单,对齐 JNPF PUT /api/permission/Authority/Data/{objectId})
// module 是一维 String[](官方 AuthorizeDataUpForm.module = String[]);
// 半选节点由调用方合并进同一数组(对齐 MenuAuth.vue: [...checkedKeys, ...halfCheckedKeys])
export const saveRoleModules = (roleId: string, moduleIds: string[]) =>
request.put(`/permission/Authority/Data/${roleId}`, {
objectType: 'role',
module: moduleIds,
});
+12
View File
@@ -0,0 +1,12 @@
import React from 'react';
import ReactDOM from 'react-dom/client';
import { BrowserRouter } from 'react-router-dom';
import App from './App';
ReactDOM.createRoot(document.getElementById('root')!).render(
<React.StrictMode>
<BrowserRouter>
<App />
</BrowserRouter>
</React.StrictMode>,
);
+26
View File
@@ -0,0 +1,26 @@
import CryptoJS from 'crypto-js';
/**
* 登录密码加密 —— 与 JNPF 后端 LiteLoginController / dacli / ssw-jnpf-lite(Vue) 完全一致。
* 检验向量:encryptPassword('123456') ===
* 'd4958348e22108119b3ef57b022c83f4bf857dd0b247eaab15b9a43d47ee3c503900f7135bf0de255bc33620c3cdc02b'
*/
const CIPHER_KEY = 'EY8WePvjM5GGwQzn';
function md5(str: string): string {
return CryptoJS.MD5(str).toString();
}
export function encryptPassword(plain: string): string {
const key = CryptoJS.enc.Utf8.parse(md5(CIPHER_KEY));
const src = CryptoJS.enc.Utf8.parse(md5(plain));
return CryptoJS.AES.encrypt(src, key, {
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7,
})
.ciphertext.toString(CryptoJS.enc.Hex);
}
export function md5Hex(str: string): string {
return md5(str);
}
+155
View File
@@ -0,0 +1,155 @@
import { useEffect, useState } from 'react';
import { listBooks, saveBook, deleteBook } from '../api/book';
import { wrap, card, btn, btnDanger, input as inputStyle, tableStyle, th, td } from './ui';
// 字段用去前缀名:id / title / author / isbn / category / price / stock
// (JNPF 后端 Jackson 会剥掉 f_ 前缀)
interface Book {
id: string;
title?: string;
author?: string;
isbn?: string;
category?: string;
price?: string;
stock?: number;
}
export default function Books() {
const [items, setItems] = useState<Book[]>([]);
const [form, setForm] = useState({
title: '',
author: '',
isbn: '',
category: '',
price: '',
stock: '',
});
async function load() {
const data = await listBooks();
setItems(data || []);
}
useEffect(() => {
load();
}, []);
function update(k: keyof Book, v: string) {
setForm((f) => ({ ...f, [k]: v }));
}
async function add() {
if (!form.title) return;
await saveBook({
title: form.title,
author: form.author || undefined,
isbn: form.isbn || undefined,
category: form.category || undefined,
price: form.price || '0.00',
stock: form.stock ? Number(form.stock) : 0,
});
setForm({ title: '', author: '', isbn: '', category: '', price: '', stock: '' });
load();
}
async function del(id: string) {
await deleteBook(id);
load();
}
return (
<div style={wrap}>
<div style={card}>
<h2 style={{ margin: 0 }}>图书超市</h2>
<div
style={{
display: 'grid',
gridTemplateColumns: 'repeat(3, minmax(140px, 1fr))',
gap: 8,
margin: '12px 0',
}}
>
<input
value={form.title}
onChange={(e) => update('title', e.target.value)}
placeholder="书名"
style={inputStyle}
/>
<input
value={form.author}
onChange={(e) => update('author', e.target.value)}
placeholder="作者"
style={inputStyle}
/>
<input
value={form.isbn}
onChange={(e) => update('isbn', e.target.value)}
placeholder="ISBN"
style={inputStyle}
/>
<input
value={form.category}
onChange={(e) => update('category', e.target.value)}
placeholder="分类"
style={inputStyle}
/>
<input
value={form.price}
onChange={(e) => update('price', e.target.value)}
placeholder="价格"
style={inputStyle}
/>
<input
value={form.stock}
onChange={(e) => update('stock', e.target.value)}
placeholder="库存"
style={inputStyle}
/>
</div>
<div style={{ display: 'flex', gap: 8 }}>
<button style={btn} onClick={add}>
新增
</button>
<button style={{ ...btn, background: '#2a3340' }} onClick={() => history.back()}>
返回
</button>
</div>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>书名</th>
<th style={th}>作者</th>
<th style={th}>ISBN</th>
<th style={th}>分类</th>
<th style={th}>价格</th>
<th style={th}>库存</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{items.map((it) => (
<tr key={it.id}>
<td style={td}>{it.title}</td>
<td style={td}>{it.author}</td>
<td style={td}>{it.isbn}</td>
<td style={td}>{it.category}</td>
<td style={td}>¥{it.price}</td>
<td style={td}>{it.stock}</td>
<td style={td}>
<button style={btnDanger} onClick={() => del(it.id)}>
删除
</button>
</td>
</tr>
))}
{items.length === 0 && (
<tr>
<td style={td} colSpan={7}>
暂无数据
</td>
</tr>
)}
</tbody>
</table>
</div>
</div>
);
}
+64
View File
@@ -0,0 +1,64 @@
import { useEffect, useState } from 'react';
import { useNavigate } from 'react-router-dom';
import { currentUser } from '../api/auth';
import { clearToken } from '../api/request';
import { wrap, card, btnGhost, btn } from './ui';
interface MenuNode {
id: string;
fullName: string;
urlAddress?: string;
icon?: string;
parentId: string;
children: MenuNode[];
}
export default function Dashboard() {
const nav = useNavigate();
const [menu, setMenu] = useState<MenuNode[]>([]);
const [user, setUser] = useState<any>(null);
useEffect(() => {
currentUser()
.then((d) => {
setMenu(d.menuList || []);
setUser(d.userInfo);
})
.catch(() => {});
}, []);
function goto(addr?: string) {
if (addr) nav('/' + addr);
}
function logout() {
clearToken();
location.reload();
}
return (
<div style={wrap}>
<div style={card}>
<h2>SSW JNPF Lite · React</h2>
<div style={{ color: '#9aa7b5' }}>
{user?.userAccount} {user?.isAdministrator ? '(管理员)' : ''}
</div>
<h3 style={{ marginTop: 16 }}>功能菜单</h3>
{menu.map((node) => (
<div key={node.id} style={{ marginBottom: 10 }}>
<div style={{ color: '#9aa7b5', fontSize: 12 }}>{node.fullName}</div>
<div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 4 }}>
{node.children.map((c) => (
<button key={c.id} style={btnGhost} onClick={() => goto(c.urlAddress)}>
{c.fullName}
</button>
))}
</div>
</div>
))}
<button style={{ ...btn, background: '#712b13', marginTop: 12 }} onClick={logout}>
退出
</button>
</div>
</div>
);
}
+146
View File
@@ -0,0 +1,146 @@
import { useEffect, useState } from 'react';
import { listDataResources, saveDataResource, deleteDataResource } from '../api/dataresource';
import { wrap, card, btn, btnDanger, input as inputStyle, tableStyle, th, td } from './ui';
// 🔴 由 `scripts/new-page.sh asset DataResource` 生成:字段来自表 `asset_data_resource` 的 DDL,
// 平台列(f_id / f_tenant_id / f_delete_mark / f_creator_* …)已经滤掉。
// `label` 暂时等于列名 —— **中文标签请按业务改**(生成器不可能猜出业务语义)。
// ⚠️ 字段名用**去前缀**名(`f_name` ⇒ `name`):后端 Jackson 会剥掉 `f_` 前缀。
interface Row {
id: string;
name?: string;
category?: string;
scenario?: string;
provider?: string;
format?: string;
scale?: string;
source?: string;
register_time?: string;
}
const FIELDS: Array<{ key: keyof Row; label: string; type: string }> = [
{ key: 'name', label: '名称', type: 'text' },
{ key: 'category', label: '分类', type: 'text' },
{ key: 'scenario', label: '场景', type: 'text' },
{ key: 'provider', label: '提供方', type: 'text' },
{ key: 'format', label: '格式', type: 'text' },
{ key: 'scale', label: '规模', type: 'text' },
{ key: 'source', label: '来源', type: 'text' },
{ key: 'register_time', label: '登记时间', type: 'datetime-local' },
];
const EMPTY: Record<string, string> = {
name: '',
category: '',
scenario: '',
provider: '',
format: '',
scale: '',
source: '',
register_time: '',
};
export default function DataResource() {
const [items, setItems] = useState<Row[]>([]);
const [form, setForm] = useState<Record<string, string>>(EMPTY);
async function load() {
const data = await listDataResources();
setItems(data || []);
}
useEffect(() => {
load();
}, []);
function update(k: string, v: string) {
setForm((f) => ({ ...f, [k]: v }));
}
async function add() {
const dto: Record<string, unknown> = {};
for (const f of FIELDS) {
const raw = form[f.key as string];
if (raw === undefined || raw === '') continue;
dto[f.key as string] = f.type === 'number' ? Number(raw) : raw;
}
await saveDataResource(dto);
setForm(EMPTY);
load();
}
async function del(id: string) {
await deleteDataResource(id);
load();
}
return (
<div style={wrap}>
<div style={card}>
<h2 style={{ margin: 0 }}>数据资源</h2>
<div
style={{
display: 'grid',
gridTemplateColumns: 'repeat(3, minmax(140px, 1fr))',
gap: 8,
margin: '12px 0',
}}
>
{FIELDS.map((f) => (
<input
key={f.key as string}
type={f.type}
value={form[f.key as string] || ''}
onChange={(e) => update(f.key as string, e.target.value)}
placeholder={f.label}
style={inputStyle}
/>
))}
</div>
<div style={{ display: 'flex', gap: 8 }}>
<button style={btn} onClick={add}>
新增
</button>
<button style={{ ...btn, background: '#2a3340' }} onClick={() => history.back()}>
返回
</button>
</div>
<table style={tableStyle}>
<thead>
<tr>
{FIELDS.map((f) => (
<th key={f.key as string} style={th}>
{f.label}
</th>
))}
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{items.map((it) => (
<tr key={it.id}>
{FIELDS.map((f) => (
<td key={f.key as string} style={td}>
{String(it[f.key] ?? '')}
</td>
))}
<td style={td}>
<button style={btnDanger} onClick={() => del(it.id)}>
删除
</button>
</td>
</tr>
))}
{items.length === 0 && (
<tr>
<td style={td} colSpan={FIELDS.length + 1}>
暂无数据
</td>
</tr>
)}
</tbody>
</table>
</div>
</div>
);
}
+101
View File
@@ -0,0 +1,101 @@
import { useEffect, useState } from 'react';
import request from '../api/request';
// 注意:字段用去前缀名(title/status/id),与 JNPF 后端 Jackson 的 f-前缀剥离一致
interface DemoItem {
id: string;
title?: string;
status?: string;
}
export default function DemoItem() {
const [items, setItems] = useState<DemoItem[]>([]);
const [title, setTitle] = useState('');
async function load() {
const data = await request.get('/ssw/demo/DemoItem/List');
setItems(data || []);
}
useEffect(() => {
load();
}, []);
async function add() {
if (!title) return;
await request.post('/ssw/demo/DemoItem/Save', { title, status: '草稿' });
setTitle('');
load();
}
async function del(id: string) {
await request.delete(`/ssw/demo/DemoItem/Delete?id=${id}`);
load();
}
return (
<div style={wrap}>
<div style={card}>
<h2>DemoItem</h2>
<div style={{ display: 'flex', gap: 8 }}>
<input
value={title}
onChange={(e) => setTitle(e.target.value)}
placeholder="标题"
style={input}
/>
<button style={btn} onClick={add}>
新增
</button>
</div>
<ul>
{items.map((it) => (
<li key={it.id} style={{ display: 'flex', gap: 12, alignItems: 'center' }}>
<span>
{it.title}({it.status})
</span>
<button style={{ ...btn, background: '#712b13' }} onClick={() => del(it.id)}>
删除
</button>
</li>
))}
</ul>
<button style={link} onClick={() => history.back()}>
返回
</button>
</div>
</div>
);
}
const wrap: React.CSSProperties = { minHeight: '100vh', padding: 40, background: '#0f1419', color: '#eee' };
const card: React.CSSProperties = {
display: 'flex',
flexDirection: 'column',
gap: 12,
padding: 24,
background: '#1a1f26',
borderRadius: 12,
minWidth: 360,
};
const input: React.CSSProperties = {
padding: 8,
borderRadius: 6,
border: '1px solid #333',
background: '#0f1419',
color: '#eee',
};
const btn: React.CSSProperties = {
padding: 8,
borderRadius: 6,
border: 0,
background: '#185fa5',
color: '#fff',
cursor: 'pointer',
};
const link: React.CSSProperties = {
padding: 8,
background: 'transparent',
border: 0,
color: '#85b7eb',
cursor: 'pointer',
textAlign: 'left',
};
+81
View File
@@ -0,0 +1,81 @@
import { useState } from 'react';
import { useNavigate, useLocation } from 'react-router-dom';
import { login } from '../api/auth';
import { setToken } from '../api/request';
import { encryptPassword } from '../utils/cipher';
export default function Login() {
const [account, setAccount] = useState('admin');
const [password, setPassword] = useState('123456');
const [err, setErr] = useState('');
const nav = useNavigate();
const loc = useLocation();
async function onSubmit(e: React.FormEvent) {
e.preventDefault();
setErr('');
try {
const hex = encryptPassword(password);
const res = await login(account, hex);
setToken(res.token);
const next = (loc.state as any)?.from?.pathname || '/';
nav(next);
} catch (e: any) {
setErr(e.message || '登录失败');
}
}
return (
<div style={wrap}>
<form onSubmit={onSubmit} style={card}>
<h2>SSW JNPF Lite · React</h2>
<input value={account} onChange={(e) => setAccount(e.target.value)} placeholder="账号" style={input} />
<input
value={password}
onChange={(e) => setPassword(e.target.value)}
type="password"
placeholder="密码"
style={input}
/>
{err && <div style={{ color: '#e24b4a' }}>{err}</div>}
<button type="submit" style={btn}>
登录
</button>
<div style={{ fontSize: 12, color: '#888' }}>默认 admin / 123456</div>
</form>
</div>
);
}
const wrap: React.CSSProperties = {
minHeight: '100vh',
display: 'flex',
alignItems: 'center',
justifyContent: 'center',
background: '#0f1419',
color: '#eee',
};
const card: React.CSSProperties = {
display: 'flex',
flexDirection: 'column',
gap: 12,
padding: 24,
background: '#1a1f26',
borderRadius: 12,
width: 300,
};
const input: React.CSSProperties = {
padding: 8,
borderRadius: 6,
border: '1px solid #333',
background: '#0f1419',
color: '#eee',
};
const btn: React.CSSProperties = {
padding: 10,
borderRadius: 6,
border: 0,
background: '#185fa5',
color: '#fff',
cursor: 'pointer',
};
+155
View File
@@ -0,0 +1,155 @@
import { useEffect, useState } from 'react';
import * as api from '../api/sys';
import { wrap, card, btn, btnDanger, btnGhost, input, tableStyle, th, td } from './ui';
export default function MenuManage() {
const [rows, setRows] = useState<any[]>([]);
const [editing, setEditing] = useState<any>(null);
const [form, setForm] = useState({
fullName: '',
urlAddress: '',
parentId: '0',
type: 2,
icon: '',
sortCode: 0,
});
async function load() {
setRows(await api.listModules());
}
useEffect(() => {
load();
}, []);
const nameOf = (id: string) =>
id === '0' ? '(根)' : (rows.find((r) => r.id === id)?.fullName ?? id);
function openEdit(r?: any) {
if (r)
setForm({
fullName: r.fullName,
urlAddress: r.urlAddress || '',
parentId: r.parentId || '0',
type: r.type ?? 2,
icon: r.icon || '',
sortCode: r.sortCode ?? 0,
});
else setForm({ fullName: '', urlAddress: '', parentId: '0', type: 2, icon: '', sortCode: 0 });
setEditing(r || {});
}
async function submit() {
if (!form.fullName) return alert('菜单名必填');
await api.saveModule({ ...form, id: editing?.id });
setEditing(null);
await load();
}
async function del(id: string) {
if (!confirm('确认删除该菜单?')) return;
await api.deleteModule(id);
await load();
}
return (
<div style={wrap}>
<div style={card}>
<h2>菜单管理</h2>
<button style={btn} onClick={() => openEdit()}>
新增菜单
</button>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>名称</th>
<th style={th}>地址(key)</th>
<th style={th}>上级</th>
<th style={th}>排序</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{rows.map((r) => (
<tr key={r.id}>
<td style={td}>{r.fullName}</td>
<td style={td}>{r.urlAddress}</td>
<td style={td}>{nameOf(r.parentId)}</td>
<td style={td}>{r.sortCode}</td>
<td style={td}>
<button style={btnGhost} onClick={() => openEdit(r)}>
编辑
</button>{' '}
<button style={btnDanger} onClick={() => del(r.id)}>
删除
</button>
</td>
</tr>
))}
</tbody>
</table>
{editing && (
<div style={{ ...card, marginTop: 16 }}>
<h3>{editing.id ? '编辑' : '新增'}菜单</h3>
<div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
<input
style={input}
placeholder="菜单名"
value={form.fullName}
onChange={(e) => setForm({ ...form, fullName: e.target.value })}
/>
<input
style={input}
placeholder="地址(key) 如 system/User"
value={form.urlAddress}
onChange={(e) => setForm({ ...form, urlAddress: e.target.value })}
/>
<select
style={input}
value={form.parentId}
onChange={(e) => setForm({ ...form, parentId: e.target.value })}
>
<option value="0">(根)</option>
{rows
.filter((r) => r.id !== editing?.id)
.map((r) => (
<option key={r.id} value={r.id}>
{r.fullName}
</option>
))}
</select>
<select
style={input}
value={form.type}
onChange={(e) => setForm({ ...form, type: +e.target.value })}
>
<option value={1}>目录</option>
<option value={2}>页面</option>
<option value={3}>按钮</option>
</select>
<input
style={input}
placeholder="图标"
value={form.icon}
onChange={(e) => setForm({ ...form, icon: e.target.value })}
/>
<input
style={input}
type="number"
placeholder="排序"
value={form.sortCode}
onChange={(e) => setForm({ ...form, sortCode: +e.target.value })}
/>
</div>
<div style={{ marginTop: 12, display: 'flex', gap: 8 }}>
<button style={btn} onClick={submit}>
保存
</button>
<button style={btnGhost} onClick={() => setEditing(null)}>
取消
</button>
</div>
</div>
)}
</div>
</div>
);
}
+112
View File
@@ -0,0 +1,112 @@
import { useEffect, useState } from 'react';
import * as api from '../api/sys';
import { wrap, card, btn, btnDanger, btnGhost, input, tableStyle, th, td } from './ui';
export default function OrganizeManage() {
const [rows, setRows] = useState<any[]>([]);
const [editing, setEditing] = useState<any>(null);
const [form, setForm] = useState({ fullName: '', parentId: '0' });
async function load() {
setRows(await api.listOrganize());
}
useEffect(() => {
load();
}, []);
const nameOf = (id: string) =>
id === '0' ? '(根)' : (rows.find((r) => r.id === id)?.fullName ?? id);
function openEdit(r?: any) {
if (r) setForm({ fullName: r.fullName, parentId: r.parentId || '0' });
else setForm({ fullName: '', parentId: '0' });
setEditing(r || {});
}
async function submit() {
if (!form.fullName) return alert('机构名必填');
await api.saveOrganize({ ...form, id: editing?.id });
setEditing(null);
await load();
}
async function del(id: string) {
if (!confirm('确认删除该机构?')) return;
try {
await api.deleteOrganize(id);
} catch (e: any) {
return alert(e.message || '删除失败');
}
await load();
}
return (
<div style={wrap}>
<div style={card}>
<h2>机构管理</h2>
<button style={btn} onClick={() => openEdit()}>
新增机构
</button>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>名称</th>
<th style={th}>上级</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{rows.map((r) => (
<tr key={r.id}>
<td style={td}>{r.fullName}</td>
<td style={td}>{nameOf(r.parentId)}</td>
<td style={td}>
<button style={btnGhost} onClick={() => openEdit(r)}>
编辑
</button>{' '}
<button style={btnDanger} onClick={() => del(r.id)}>
删除
</button>
</td>
</tr>
))}
</tbody>
</table>
{editing && (
<div style={{ ...card, marginTop: 16 }}>
<h3>{editing.id ? '编辑' : '新增'}机构</h3>
<div style={{ display: 'flex', gap: 8 }}>
<input
style={input}
placeholder="机构名"
value={form.fullName}
onChange={(e) => setForm({ ...form, fullName: e.target.value })}
/>
<select
style={input}
value={form.parentId}
onChange={(e) => setForm({ ...form, parentId: e.target.value })}
>
<option value="0">(根)</option>
{rows
.filter((r) => r.id !== editing?.id)
.map((r) => (
<option key={r.id} value={r.id}>
{r.fullName}
</option>
))}
</select>
</div>
<div style={{ marginTop: 12, display: 'flex', gap: 8 }}>
<button style={btn} onClick={submit}>
保存
</button>
<button style={btnGhost} onClick={() => setEditing(null)}>
取消
</button>
</div>
</div>
)}
</div>
</div>
);
}
+93
View File
@@ -0,0 +1,93 @@
import { useEffect, useState } from 'react';
import { listProducts, saveProduct, deleteProduct } from '../api/product';
import { wrap, card, btn, btnDanger, input as inputStyle, tableStyle, th, td } from './ui';
// 字段用去前缀名:id / title / price(后端 Jackson 会剥掉 f_ 前缀)
interface Product {
id: string;
title?: string;
price?: string;
}
export default function Product() {
const [items, setItems] = useState<Product[]>([]);
const [title, setTitle] = useState('');
const [price, setPrice] = useState('');
async function load() {
const data = await listProducts();
setItems(data || []);
}
useEffect(() => {
load();
}, []);
async function add() {
if (!title) return;
await saveProduct({ title, price: price || '0.00' });
setTitle('');
setPrice('');
load();
}
async function del(id: string) {
await deleteProduct(id);
load();
}
return (
<div style={wrap}>
<div style={card}>
<h2 style={{ margin: 0 }}>产品管理</h2>
<div style={{ display: 'flex', gap: 8, margin: '12px 0' }}>
<input
value={title}
onChange={(e) => setTitle(e.target.value)}
placeholder="产品名称"
style={inputStyle}
/>
<input
value={price}
onChange={(e) => setPrice(e.target.value)}
placeholder="价格"
style={{ ...inputStyle, width: 100 }}
/>
<button style={btn} onClick={add}>
新增
</button>
<button style={{ ...btn, background: '#2a3340' }} onClick={() => history.back()}>
返回
</button>
</div>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>名称</th>
<th style={th}>价格</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{items.map((it) => (
<tr key={it.id}>
<td style={td}>{it.title}</td>
<td style={td}>¥{it.price}</td>
<td style={td}>
<button style={btnDanger} onClick={() => del(it.id)}>
删除
</button>
</td>
</tr>
))}
{items.length === 0 && (
<tr>
<td style={td} colSpan={3}>
暂无数据
</td>
</tr>
)}
</tbody>
</table>
</div>
</div>
);
}
+153
View File
@@ -0,0 +1,153 @@
import { useEffect, useState } from 'react';
import * as api from '../api/sys';
import { wrap, card, btn, btnDanger, btnGhost, input, tableStyle, th, td } from './ui';
export default function RoleManage() {
const [rows, setRows] = useState<any[]>([]);
const [modules, setModules] = useState<any[]>([]);
const [editing, setEditing] = useState<any>(null);
const [form, setForm] = useState({ fullName: '', enCode: '', description: '' });
// 授权面板
const [authRoleId, setAuthRoleId] = useState('');
const [checked, setChecked] = useState<string[]>([]);
async function load() {
setRows(await api.listRoles());
setModules(await api.listModules());
}
useEffect(() => {
load();
}, []);
function openEdit(r?: any) {
if (r) setForm({ fullName: r.fullName, enCode: r.enCode || '', description: r.description || '' });
else setForm({ fullName: '', enCode: '', description: '' });
setEditing(r || {});
}
async function submit() {
if (!form.fullName) return alert('角色名必填');
await api.saveRole({ ...form, id: editing?.id });
setEditing(null);
await load();
}
async function del(id: string) {
if (!confirm('确认删除该角色?')) return;
await api.deleteRole(id);
await load();
}
async function openAuth(roleId: string) {
setAuthRoleId(roleId);
const ids = (await api.roleModules(roleId)) || [];
setChecked(ids);
}
async function saveAuth() {
await api.saveRoleModules(authRoleId, checked);
alert('授权已保存');
}
return (
<div style={wrap}>
<div style={card}>
<h2>角色管理</h2>
<button style={btn} onClick={() => openEdit()}>
新增角色
</button>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>角色名</th>
<th style={th}>编码</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{rows.map((r) => (
<tr key={r.id}>
<td style={td}>{r.fullName}</td>
<td style={td}>{r.enCode}</td>
<td style={td}>
<button style={btnGhost} onClick={() => openEdit(r)}>
编辑
</button>{' '}
<button style={btnGhost} onClick={() => openAuth(r.id)}>
授权菜单
</button>{' '}
<button style={btnDanger} onClick={() => del(r.id)}>
删除
</button>
</td>
</tr>
))}
</tbody>
</table>
{editing && (
<div style={{ ...card, marginTop: 16 }}>
<h3>{editing.id ? '编辑' : '新增'}角色</h3>
<div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
<input
style={input}
placeholder="角色名"
value={form.fullName}
onChange={(e) => setForm({ ...form, fullName: e.target.value })}
/>
<input
style={input}
placeholder="编码"
value={form.enCode}
onChange={(e) => setForm({ ...form, enCode: e.target.value })}
/>
<input
style={input}
placeholder="描述"
value={form.description}
onChange={(e) => setForm({ ...form, description: e.target.value })}
/>
</div>
<div style={{ marginTop: 12, display: 'flex', gap: 8 }}>
<button style={btn} onClick={submit}>
保存
</button>
<button style={btnGhost} onClick={() => setEditing(null)}>
取消
</button>
</div>
</div>
)}
{authRoleId && (
<div style={{ ...card, marginTop: 16 }}>
<h3>角色菜单授权({authRoleId})</h3>
<div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
{modules.map((m) => (
<label key={m.id}>
<input
type="checkbox"
checked={checked.includes(m.id)}
onChange={(e) =>
setChecked((prev) =>
e.target.checked
? [...prev, m.id]
: prev.filter((x) => x !== m.id),
)
}
/>{' '}
{m.fullName}
<span style={{ color: '#7a8794' }}> ({m.urlAddress})</span>
</label>
))}
</div>
<div style={{ marginTop: 12, display: 'flex', gap: 8 }}>
<button style={btn} onClick={saveAuth}>
保存授权
</button>
<button style={btnGhost} onClick={() => setAuthRoleId('')}>
关闭
</button>
</div>
</div>
)}
</div>
</div>
);
}
+148
View File
@@ -0,0 +1,148 @@
import { useEffect, useState } from 'react';
import * as api from '../api/sys';
import { wrap, card, btn, btnDanger, btnGhost, input, tableStyle, th, td } from './ui';
export default function UserManage() {
const [rows, setRows] = useState<any[]>([]);
const [roleOptions, setRoleOptions] = useState<any[]>([]);
const [editing, setEditing] = useState<any>(null);
const [form, setForm] = useState({
account: '',
realName: '',
password: '',
isAdministrator: false,
roleIds: [] as string[],
});
async function load() {
setRows(await api.listUsers());
setRoleOptions(await api.listRoles());
}
useEffect(() => {
load();
}, []);
function openEdit(r?: any) {
if (r)
setForm({
account: r.account,
realName: r.realName || '',
password: '',
isAdministrator: r.isAdministrator === 1,
roleIds: r.roleIds || [],
});
else setForm({ account: '', realName: '', password: '', isAdministrator: false, roleIds: [] });
setEditing(r || {});
}
async function submit() {
if (!form.account) return alert('账号必填');
await api.saveUser({ ...form, id: editing?.id });
setEditing(null);
await load();
}
async function del(id: string) {
if (!confirm('确认删除该用户?')) return;
await api.deleteUser(id);
await load();
}
return (
<div style={wrap}>
<div style={card}>
<h2>用户管理</h2>
<button style={btn} onClick={() => openEdit()}>
新增用户
</button>
<table style={tableStyle}>
<thead>
<tr>
<th style={th}>账号</th>
<th style={th}>姓名</th>
<th style={th}>角色</th>
<th style={th}>管理员</th>
<th style={th}>操作</th>
</tr>
</thead>
<tbody>
{rows.map((r) => (
<tr key={r.id}>
<td style={td}>{r.account}</td>
<td style={td}>{r.realName}</td>
<td style={td}>{(r.roleNames || []).join(',')}</td>
<td style={td}>{r.isAdministrator === 1 ? '是' : '否'}</td>
<td style={td}>
<button style={btnGhost} onClick={() => openEdit(r)}>
编辑
</button>{' '}
<button style={btnDanger} onClick={() => del(r.id)}>
删除
</button>
</td>
</tr>
))}
</tbody>
</table>
{editing && (
<div style={{ ...card, marginTop: 16 }}>
<h3>{editing.id ? '编辑' : '新增'}用户</h3>
<div style={{ display: 'flex', gap: 8, flexWrap: 'wrap', alignItems: 'center' }}>
<input
style={input}
placeholder="账号"
value={form.account}
onChange={(e) => setForm({ ...form, account: e.target.value })}
/>
<input
style={input}
placeholder="姓名"
value={form.realName}
onChange={(e) => setForm({ ...form, realName: e.target.value })}
/>
<input
style={input}
placeholder="密码(留空不改)"
type="password"
value={form.password}
onChange={(e) => setForm({ ...form, password: e.target.value })}
/>
<label>
<input
type="checkbox"
checked={form.isAdministrator}
onChange={(e) => setForm({ ...form, isAdministrator: e.target.checked })}
/>{' '}
管理员
</label>
<select
multiple
style={input}
value={form.roleIds}
onChange={(e) =>
setForm({
...form,
roleIds: Array.from(e.target.selectedOptions).map((o) => o.value),
})
}
>
{roleOptions.map((r) => (
<option key={r.id} value={r.id}>
{r.fullName}
</option>
))}
</select>
</div>
<div style={{ marginTop: 12, display: 'flex', gap: 8 }}>
<button style={btn} onClick={submit}>
保存
</button>
<button style={btnGhost} onClick={() => setEditing(null)}>
取消
</button>
</div>
</div>
)}
</div>
</div>
);
}
+46
View File
@@ -0,0 +1,46 @@
import { CSSProperties } from 'react';
export const wrap: CSSProperties = {
minHeight: '100vh',
padding: 24,
background: '#0f1419',
color: '#eee',
fontFamily: 'system-ui, sans-serif',
};
export const card: CSSProperties = {
background: '#1a1f26',
borderRadius: 12,
padding: 20,
};
export const btn: CSSProperties = {
padding: '8px 14px',
borderRadius: 6,
border: 0,
background: '#185fa5',
color: '#fff',
cursor: 'pointer',
};
export const btnDanger: CSSProperties = { ...btn, background: '#a1322b' };
export const btnGhost: CSSProperties = { ...btn, background: '#2a3340' };
export const input: CSSProperties = {
padding: 8,
borderRadius: 6,
border: '1px solid #333',
background: '#0f1419',
color: '#eee',
};
export const tableStyle: CSSProperties = {
width: '100%',
borderCollapse: 'collapse',
marginTop: 12,
};
export const th: CSSProperties = {
textAlign: 'left',
padding: '8px',
borderBottom: '1px solid #2a3340',
color: '#9aa7b5',
};
export const td: CSSProperties = {
padding: '8px',
borderBottom: '1px solid #1f2630',
};
+20
View File
@@ -0,0 +1,20 @@
{
"compilerOptions": {
"target": "ES2020",
"useDefineForClassFields": true,
"lib": ["ES2020", "DOM", "DOM.Iterable"],
"module": "ESNext",
"skipLibCheck": true,
"moduleResolution": "bundler",
"allowImportingTsExtensions": true,
"resolveJsonModule": true,
"isolatedModules": true,
"noEmit": true,
"jsx": "react-jsx",
"strict": false,
"noUnusedLocals": false,
"noUnusedParameters": false,
"esModuleInterop": true
},
"include": ["src"]
}
+22
View File
@@ -0,0 +1,22 @@
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
server: {
host: '127.0.0.1', // macOS 上 vite 默认只 bind ::1 (IPv6),强制 IPv4 避免 127.0.0.1 被 reset
port: 5173,
strictPort: true, // 端口被占直接报错而不是自动换端口(让 perm-smoke 端口断言稳定)
proxy: {
// 所有 /api 请求转发到本仓后端。
//
// 🔴 **端口是 30010,不是技能模板里的 30000**:
// React 技能模板的后端是 NestJS(:30000),而本仓后端换成了 Rust
// (`src/backend/src/main.rs` 的 `PORT` 缺省 **30010**)。
// ⇒ 照抄模板不改这里,前端每个请求都会 502,而浏览器只会说「Network Error」
// —— 排查时最容易怀疑「跨域 / 认证」,其实只是端口抄错了。
// 改后端默认端口时,这里要跟着改(或用 `PORT=` 起后端时同样指定)。
'/api': 'http://127.0.0.1:30010',
},
},
});