joylink/rtsa-services
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: joylink:25a63b1fb7fe39d5e2ea303ae585e49e355d9822
Branches Tags
joylink:main
joylink:local-test
..
compare: joylink:5ce122af289f4b0d2344a8e283fab67cae8abc20
Branches Tags
joylink:local-test
joylink:main

No commits in common. "25a63b1fb7fe39d5e2ea303ae585e49e355d9822" and "5ce122af289f4b0d2344a8e283fab67cae8abc20" have entirely different histories.
25a63b1fb7 ... 5ce122af28

47 changed files with 1059 additions and 3980 deletions
Show Stats Expand all files Collapse all files

3
.gitea/workflows/cicd_local_test.yml
View File

@ -14,9 +14,6 @@ jobs:
with:
submodules: recursive
- uses: https://gitea.joylink.club/actions/rust-cache@v2
with:
cache-on-failure: true
cache-all-crates: true
- name: Install musl-tools
run: apt-get update && apt-get install -y musl-tools
- name: build Release

57
Cargo.lock generated
View File

@ -1633,27 +1633,14 @@ name = "manager"
version = "0.1.0"
dependencies = [
"anyhow",
"async-graphql",
"async-graphql-axum",
"axum",
"axum-extra",
"base64 0.22.1",
"chrono",
"clap",
"config",
"enum_dispatch",
"jsonwebtoken",
"reqwest",
"rtsa_api",
"rtsa_db",
"rtsa_dto",
"rtsa_log",
"serde",
"serde_json",
"sqlx",
"sysinfo",
"thiserror",
"tokio",
"tower-http",
]
[[package]]
@ -2281,14 +2268,14 @@ dependencies = [
[[package]]
name = "regex"
version = "1.11.1"
version = "1.10.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
dependencies = [
"aho-corasick",
"memchr",
"regex-automata 0.4.8",
"regex-syntax 0.8.5",
"regex-automata 0.4.7",
"regex-syntax 0.8.4",
]
[[package]]
@ -2302,13 +2289,13 @@ dependencies = [
[[package]]
name = "regex-automata"
version = "0.4.8"
version = "0.4.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax 0.8.5",
"regex-syntax 0.8.4",
]
[[package]]
@ -2319,9 +2306,9 @@ checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
[[package]]
name = "regex-syntax"
version = "0.8.5"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
[[package]]
name = "reqwest"
@ -2412,13 +2399,35 @@ dependencies = [
"zeroize",
]
[[package]]
name = "rtsa_api"
version = "0.1.0"
dependencies = [
"anyhow",
"async-graphql",
"async-graphql-axum",
"axum",
"axum-extra",
"base64 0.22.1",
"chrono",
"jsonwebtoken",
"reqwest",
"rtsa_db",
"rtsa_dto",
"rtsa_log",
"serde",
"serde_json",
"sysinfo",
"tokio",
"tower-http",
]
[[package]]
name = "rtsa_db"
version = "0.1.0"
dependencies = [
"anyhow",
"lazy_static",
"regex",
"rtsa_dto",
"rtsa_log",
"serde",

3
Cargo.toml
View File

@ -1,6 +1,6 @@
[workspace]
members = ["crates/*", "manager", "simulation"]
members = ["crates/*", "manager/crates/*", "manager", "simulation"]
resolver = "2"
[workspace.dependencies]
@ -27,4 +27,3 @@ config = "0.14.1"
clap = { version = "4.5.20", features = ["derive"] }
enum_dispatch = "0.3"
tower = { version = "0.5.1", features = ["util"] }
regex = "1.11.1"

1
crates/rtsa_db/Cargo.toml
View File

@ -18,7 +18,6 @@ sqlx = { workspace = true, features = [
] }
thiserror = { workspace = true }
lazy_static = { workspace = true }
regex = { workspace = true }
rtsa_dto = { path = "../rtsa_dto" }
rtsa_log = { path = "../rtsa_log" }

4
crates/rtsa_db/src/common.rs
View File

@ -107,12 +107,12 @@ impl Display for SortOrder {
}
#[derive(Debug)]
pub struct PageData<T> {
pub struct PageResult<T> {
pub total: i64,
pub data: Vec<T>,
}
impl<T> PageData<T> {
impl<T> PageResult<T> {
pub fn new(total: i64, data: Vec<T>) -> Self {
Self { total, data }
}

113
crates/rtsa_db/src/db_access/draft_data.rs
View File

@ -1,10 +1,11 @@
use std::vec;
use rtsa_dto::common::DataType;
use rtsa_log::tracing::debug;
use serde_json::Value;
use crate::{
common::{PageData, PageQuery, Sort, SortOrder, TableColumn},
common::{PageQuery, PageResult, Sort, SortOrder, TableColumn},
model::{DraftDataColumn, DraftDataModel},
DbAccessError,
};
@ -19,14 +20,14 @@ pub trait DraftDataAccessor {
&self,
query: DraftDataQuery,
page: PageQuery,
) -> Result<PageData<DraftDataModel>, DbAccessError>;
) -> Result<PageResult<DraftDataModel>, DbAccessError>;
/// 根据id查询草稿数据
async fn query_draft_data_by_id(&self, id: i32) -> Result<DraftDataModel, DbAccessError>;
/// 是否user_id+data_type+name的数据已存在
async fn is_draft_data_exist(
&self,
user_id: i32,
data_type: i32,
data_type: &DataType,
name: &str,
) -> Result<bool, DbAccessError>;
/// 创建草稿数据基本信息
@ -73,7 +74,7 @@ pub trait DraftDataAccessor {
pub struct DraftDataQuery {
pub user_id: Option<i32>,
pub name: Option<String>,
pub data_type: Option<i32>,
pub data_type: Option<DataType>,
pub options: Option<Value>,
pub is_shared: Option<bool>,
}
@ -93,7 +94,7 @@ impl DraftDataQuery {
self
}
pub fn with_data_type(mut self, data_type: i32) -> Self {
pub fn with_data_type(mut self, data_type: DataType) -> Self {
self.data_type = Some(data_type);
self
}
@ -129,7 +130,7 @@ impl DraftDataQuery {
filters.push(format!(
"{} = {}",
DraftDataColumn::DataType.name(),
data_type
data_type as i32
));
}
if let Some(is_shared) = self.is_shared {
@ -156,7 +157,7 @@ impl DraftDataQuery {
pub struct CreateDraftData {
name: String,
data_type: i32,
data_type: DataType,
options: Option<Value>,
data: Option<Vec<u8>>,
default_release_data_id: Option<i32>,
@ -164,7 +165,7 @@ pub struct CreateDraftData {
}
impl CreateDraftData {
pub fn new(name: &str, data_type: i32, user_id: i32) -> Self {
pub fn new(name: &str, data_type: DataType, user_id: i32) -> Self {
CreateDraftData {
name: name.to_string(),
data_type,
@ -209,7 +210,7 @@ impl DraftDataAccessor for RtsaDbAccessor {
&self,
query: DraftDataQuery,
page: PageQuery,
) -> Result<PageData<DraftDataModel>, DbAccessError> {
) -> Result<PageResult<DraftDataModel>, DbAccessError> {
let table = DraftDataColumn::Table.name();
let where_clause = query.build_filter();
let sql = format!("SELECT COUNT(*) FROM {table} {where_clause}");
@ -219,7 +220,7 @@ impl DraftDataAccessor for RtsaDbAccessor {
let total: i64 = sqlx::query_scalar(&sql).fetch_one(&self.pool).await?;
if total == 0 {
return Ok(PageData::new(total, vec![]));
return Ok(PageResult::new(total, vec![]));
}
let select_columns = format!(
@ -244,7 +245,7 @@ impl DraftDataAccessor for RtsaDbAccessor {
debug!("paging sql: {}", paging_sql);
let list: Vec<DraftDataModel> = sqlx::query_as(&paging_sql).fetch_all(&self.pool).await?;
Ok(PageData::new(total, list))
Ok(PageResult::new(total, list))
}
async fn query_draft_data_by_id(&self, id: i32) -> Result<DraftDataModel, DbAccessError> {
@ -258,7 +259,7 @@ impl DraftDataAccessor for RtsaDbAccessor {
async fn is_draft_data_exist(
&self,
user_id: i32,
data_type: i32,
data_type: &DataType,
name: &str,
) -> Result<bool, DbAccessError> {
let table = DraftDataColumn::Table.name();
@ -284,12 +285,10 @@ impl DraftDataAccessor for RtsaDbAccessor {
) -> Result<DraftDataModel, DbAccessError> {
// 检查是否已存在
let exist = self
.is_draft_data_exist(create.user_id, create.data_type, &create.name)
.is_draft_data_exist(create.user_id, &create.data_type, &create.name)
.await?;
if exist {
return Err(DbAccessError::RowExist(
"uid + data_type + name".to_string(),
));
return Err(DbAccessError::RowExist);
}
// 插入数据
let table = DraftDataColumn::Table.name();
@ -434,57 +433,14 @@ impl DraftDataAccessor for RtsaDbAccessor {
#[cfg(test)]
mod tests {
use crate::{RegisterUser, UserAccessor};
use crate::{SyncUserInfo, UserAccessor};
use super::*;
use rtsa_dto::common::{IscsStyle, Role};
use rtsa_log::tracing::Level;
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
/// 数据类型
#[derive(
sqlx::Type,
serde::Serialize,
serde::Deserialize,
Clone,
Copy,
Debug,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
)]
#[repr(i32)]
pub enum DataType {
/// 数据类型未知
Unknown = 0,
/// 电子地图数据
Em = 1,
/// ISCS数据
Iscs = 4,
}
use sqlx::{types::chrono::Local, PgPool};
/// 数据类型
#[derive(
sqlx::Type,
serde::Serialize,
serde::Deserialize,
Clone,
Copy,
Debug,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
)]
#[repr(i32)]
pub enum IscsStyle {
/// 数据类型未知
Unknown = 0,
/// 电子地图数据
Style1 = 1,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IscsDataOptions {
pub style: IscsStyle,
@ -495,15 +451,26 @@ mod tests {
async fn basic_use_test(pool: PgPool) -> Result<(), DbAccessError> {
rtsa_log::Logging::default().with_level(Level::DEBUG).init();
let accessor = crate::db_access::RtsaDbAccessor::new(pool);
// 注册10个用户
// 同步10个用户
let mut users = vec![];
for i in 0..10 {
let user = RegisterUser::new(&format!("test{}", i), "123456");
accessor.register_user(user).await?;
let user = SyncUserInfo {
id: i + 1,
name: format!("user{}", i + 1),
password: "password".to_string(),
roles: serde_json::to_value(vec![Role::User]).unwrap(),
email: None,
mobile: None,
created_at: Local::now(),
updated_at: None,
};
users.push(user);
}
accessor.sync_user(users.as_slice()).await?;
// 创建草稿数据测试
let res = accessor
.create_draft_data(CreateDraftData::new("test", DataType::Em as i32, 10))
.create_draft_data(CreateDraftData::new("test", DataType::Em, 10))
.await?;
println!("res: {:?}", res);
@ -512,11 +479,11 @@ mod tests {
// 重复创建测试
let repeat_create_result = accessor
.create_draft_data(CreateDraftData::new("test", DataType::Em as i32, 10))
.create_draft_data(CreateDraftData::new("test", DataType::Em, 10))
.await;
if let Some(e) = repeat_create_result.err() {
match e {
DbAccessError::RowExist(_) => {
DbAccessError::RowExist => {
println!("repeat create test pass");
}
_ => {
@ -584,10 +551,10 @@ mod tests {
if i == 1 {
let draft = accessor
.create_draft_data(
CreateDraftData::new(&format!("test{}", j), DataType::Iscs as i32, i)
CreateDraftData::new(&format!("test{}", j), DataType::Iscs, i)
.with_options(
serde_json::to_value(IscsDataOptions {
style: IscsStyle::Style1,
style: IscsStyle::DaShiZhiNeng,
})
.unwrap(),
),
@ -599,7 +566,7 @@ mod tests {
accessor
.create_draft_data(CreateDraftData::new(
&format!("test{}", j),
DataType::Em as i32,
DataType::Em,
i,
))
.await?;
@ -612,7 +579,7 @@ mod tests {
DraftDataQuery::new()
.with_user_id(2)
.with_name("test".to_string())
.with_data_type(DataType::Em as i32),
.with_data_type(DataType::Em),
PageQuery::new(1, 10),
)
.await?;
@ -637,7 +604,7 @@ mod tests {
.paging_query_draft_data(
DraftDataQuery::new().with_options(
serde_json::to_value(IscsDataOptions {
style: IscsStyle::Style1,
style: IscsStyle::DaShiZhiNeng,
})
.unwrap(),
),

33
crates/rtsa_db/src/db_access/feature.rs
View File

@ -2,7 +2,7 @@ use rtsa_dto::common::FeatureType;
use serde_json::Value;
use crate::{
common::{PageData, PageQuery, TableColumn},
common::{PageQuery, PageResult, TableColumn},
model::{FeatureColumn, FeatureModel},
DbAccessError,
};
@ -27,7 +27,7 @@ pub trait FeatureAccessor {
&self,
page: PageQuery,
filter: &FeaturePagingFilter,
) -> Result<PageData<FeatureModel>, DbAccessError>;
) -> Result<PageResult<FeatureModel>, DbAccessError>;
/// 获取id对应的功能特性
async fn get_feature(&self, id: i32) -> Result<FeatureModel, DbAccessError>;
/// 根据id列表获取功能特性基本信息
@ -102,7 +102,7 @@ impl FeatureAccessor for RtsaDbAccessor {
&self,
page: PageQuery,
filter: &FeaturePagingFilter,
) -> Result<PageData<FeatureModel>, DbAccessError> {
) -> Result<PageResult<FeatureModel>, DbAccessError> {
let table = FeatureColumn::Table.name();
let where_clause = filter.to_where_clause();
let total =
@ -110,7 +110,7 @@ impl FeatureAccessor for RtsaDbAccessor {
.fetch_one(&self.pool)
.await?;
if total == 0 {
return Ok(PageData::new(total, vec![]));
return Ok(PageResult::new(total, vec![]));
}
let update_at_column = FeatureColumn::UpdatedAt.name();
let select_columns = [
@ -132,7 +132,7 @@ impl FeatureAccessor for RtsaDbAccessor {
let rows = sqlx::query_as::<_, FeatureModel>(&sql)
.fetch_all(&self.pool)
.await?;
Ok(PageData::new(total, rows))
Ok(PageResult::new(total, rows))
}
async fn get_feature(&self, id: i32) -> Result<FeatureModel, DbAccessError> {
@ -217,11 +217,11 @@ impl FeaturePagingFilter {
#[cfg(test)]
mod tests {
use rtsa_dto::common::Role;
use rtsa_log::tracing::Level;
use sqlx::PgPool;
use sqlx::{types::chrono::Local, PgPool};
use crate::{RegisterUser, UserAccessor};
use crate::{SyncUserInfo, UserAccessor};
use super::*;
@ -229,11 +229,22 @@ mod tests {
async fn test_basic_use(pool: PgPool) -> Result<(), DbAccessError> {
rtsa_log::Logging::default().with_level(Level::DEBUG).init();
let accessor = crate::db_access::RtsaDbAccessor::new(pool);
// 注册10个用户
// 同步10个用户
let mut users = vec![];
for i in 0..10 {
let user = RegisterUser::new(&format!("test{}", i), "123456");
accessor.register_user(user).await?;
let user = SyncUserInfo {
id: i + 1,
name: format!("user{}", i + 1),
password: "password".to_string(),
roles: serde_json::to_value(vec![Role::User]).unwrap(),
email: None,
mobile: None,
created_at: Local::now(),
updated_at: None,
};
users.push(user);
}
accessor.sync_user(users.as_slice()).await?;
// 创建测试
let creator_id = 1;

14
crates/rtsa_db/src/db_access/mod.rs
View File

@ -10,10 +10,6 @@ pub use user::*;
mod feature;
pub use feature::*;
use lazy_static::lazy_static;
mod org;
pub use org::*;
mod org_user;
pub use org_user::*;
use crate::{model::MqttClientIdSeq, DbAccessError};
@ -32,16 +28,6 @@ pub async fn init_default_db_accessor(url: &str) {
*rda = Some(accessor);
}
/// 设置全局默认数据库访问器
pub fn set_default_db_accessor(accessor: RtsaDbAccessor) {
if RDA.lock().unwrap().is_some() {
error!("数据库访问器已初始化，请勿重复初始化");
return;
}
let mut rda = RDA.lock().unwrap();
*rda = Some(accessor);
}
/// 获取默认数据库访问器
pub fn get_default_db_accessor() -> RtsaDbAccessor {
let rda = RDA.lock().unwrap();

669
crates/rtsa_db/src/db_access/org.rs
View File

@ -1,669 +0,0 @@
use serde_json::Value;
use crate::{
common::{PageData, PageQuery, TableColumn},
model::{OrganizationColumn, OrganizationModel},
DbAccessError,
};
use super::RtsaDbAccessor;
/// 组织数据管理
#[allow(async_fn_in_trait)]
pub trait OrgAccessor {
/// 组织code是否存在
async fn is_org_code_exist(&self, code: &str) -> Result<bool, DbAccessError>;
/// 创建组织
async fn create_org(&self, create: CreateOrg) -> Result<OrganizationModel, DbAccessError>;
/// 获取组织
async fn query_org(&self, id: i32) -> Result<OrganizationModel, DbAccessError>;
/// 根据id列表获取组织name
async fn query_org_names(&self, ids: &[i32]) -> Result<Vec<(i32, String)>, DbAccessError>;
/// 通过code获取组织
async fn query_org_by_code(&self, code: &str) -> Result<OrganizationModel, DbAccessError>;
/// 分页获取顶级组织
async fn query_org_top_page(
&self,
page: PageQuery,
filter: OrgTopFilter,
) -> Result<PageData<OrganizationModel>, DbAccessError>;
/// 获取所有顶级组织
async fn query_org_top(&self) -> Result<Vec<OrganizationModel>, DbAccessError>;
/// 获取某组织的顶级组织
async fn query_org_top_of_org(&self, org_id: i32) -> Result<OrganizationModel, DbAccessError>;
/// 获取所有下一级子组织
async fn query_org_children(
&self,
parent_id: i32,
) -> Result<Vec<OrganizationModel>, DbAccessError>;
/// 通过id列表获取组织code和name
async fn query_org_name_by_ids(
&self,
ids: Vec<i32>,
) -> Result<Vec<(i32, String)>, DbAccessError>;
/// 更新组织名称
async fn update_org_name(
&self,
id: i32,
name: &str,
updater_id: i32,
) -> Result<OrganizationModel, DbAccessError>;
/// 更新组织配置
async fn update_org_config(
&self,
id: i32,
config: Value,
updater_id: i32,
) -> Result<OrganizationModel, DbAccessError>;
/// 删除组织
/// 警告：删除组织会关联删除组织关联的所有数据
async fn delete_org(&self, id: i32) -> Result<(), DbAccessError>;
}
pub struct CreateOrg {
pub parent_id: Option<i32>,
pub code: Option<String>,
pub name: String,
pub config: Option<Value>,
pub creator_id: i32,
}
impl CreateOrg {
pub fn new(name: &str, creator_id: i32) -> CreateOrg {
CreateOrg {
parent_id: None,
code: None,
name: name.to_string(),
config: None,
creator_id,
}
}
pub fn with_parent_id(mut self, parent_id: i32) -> Self {
self.parent_id = Some(parent_id);
self
}
pub fn with_code(mut self, code: &str) -> Self {
self.code = Some(code.to_string());
self
}
pub fn with_config(mut self, config: Value) -> Self {
self.config = Some(config);
self
}
}
pub struct OrgTopFilter {
pub code: Option<String>,
pub name: Option<String>,
}
impl OrgTopFilter {
pub fn to_where_clause(&self) -> String {
let mut clauses = vec![];
let code_column = OrganizationColumn::Id.name();
let name_column = OrganizationColumn::Name.name();
if let Some(code) = &self.code {
clauses.push(format!("{} = '{}'", code_column, code));
}
if let Some(name) = &self.name {
clauses.push(format!("{} = '{}'", name_column, name));
}
if clauses.is_empty() {
"".to_string()
} else {
format!("WHERE {}", clauses.join(" AND "))
}
}
}
impl OrgAccessor for RtsaDbAccessor {
async fn is_org_code_exist(&self, code: &str) -> Result<bool, DbAccessError> {
let table = OrganizationColumn::Table.name();
let code_column = OrganizationColumn::Code.name();
let sql = format!(
"SELECT COUNT(1) FROM {table} WHERE {code_column} = $1",
table = table,
code_column = code_column
);
let count: i64 = sqlx::query_scalar(&sql)
.bind(code)
.fetch_one(&self.pool)
.await?;
Ok(count > 0)
}
async fn create_org(&self, create: CreateOrg) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let parent_id_column = OrganizationColumn::ParentId.name();
let code_column = OrganizationColumn::Code.name();
let name_column = OrganizationColumn::Name.name();
let config_column = OrganizationColumn::Config.name();
let creator_id_column = OrganizationColumn::CreatorId.name();
let updater_id_column = OrganizationColumn::UpdaterId.name();
let sql = format!(
"INSERT INTO {table} ({parent_id_column}, {code_column}, {name_column}, {config_column}, {creator_id_column}, {updater_id_column}) VALUES ($1, $2, $3, $4, $5, $5) RETURNING *",
table = table,
parent_id_column = parent_id_column,
code_column = code_column,
name_column = name_column,
config_column = config_column,
creator_id_column = creator_id_column,
updater_id_column = updater_id_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(create.parent_id)
.bind(create.code)
.bind(create.name)
.bind(create.config)
.bind(create.creator_id)
.bind(create.creator_id)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn query_org(&self, id: i32) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let sql = format!(
"SELECT * FROM {table} WHERE {id_column} = $1",
table = table,
id_column = id_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn query_org_names(&self, ids: &[i32]) -> Result<Vec<(i32, String)>, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let name_column = OrganizationColumn::Name.name();
let sql = format!(
"SELECT {id_column}, {name_column} FROM {table} WHERE {id_column} = ANY($1)",
id_column = id_column,
name_column = name_column,
table = table
);
let rows: Vec<(i32, String)> = sqlx::query_as(&sql).bind(ids).fetch_all(&self.pool).await?;
Ok(rows)
}
async fn query_org_by_code(&self, code: &str) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let code_column = OrganizationColumn::Code.name();
let sql = format!(
"SELECT * FROM {table} WHERE {code_column} = $1",
table = table,
code_column = code_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(code)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn query_org_top_page(
&self,
page: PageQuery,
filter: OrgTopFilter,
) -> Result<PageData<OrganizationModel>, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let where_clause = filter.to_where_clause();
let count_clause = format!("SELECT COUNT({id_column}) FROM {table} {where_clause}");
let total: i64 = sqlx::query_scalar(&count_clause)
.fetch_one(&self.pool)
.await?;
if total == 0 {
return Ok(PageData::new(total, vec![]));
}
let limit_clause = page.to_limit_clause();
let sql = format!(
"SELECT * FROM {table} {where_clause} ORDER BY {id_column} {limit_clause}",
table = table,
where_clause = where_clause,
id_column = id_column,
limit_clause = limit_clause
);
let rows = sqlx::query_as::<_, OrganizationModel>(&sql)
.fetch_all(&self.pool)
.await?;
Ok(PageData::new(total, rows))
}
async fn query_org_top(&self) -> Result<Vec<OrganizationModel>, DbAccessError> {
let table = OrganizationColumn::Table.name();
let parent_id_column = OrganizationColumn::ParentId.name();
let sql = format!(
"SELECT * FROM {table} WHERE {parent_id_column} IS NULL",
table = table,
parent_id_column = parent_id_column
);
let rows = sqlx::query_as::<_, OrganizationModel>(&sql)
.fetch_all(&self.pool)
.await?;
Ok(rows)
}
async fn query_org_top_of_org(&self, org_id: i32) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let parent_id_column = OrganizationColumn::ParentId.name();
let sql = format!(
"WITH RECURSIVE org_tree AS (
SELECT * FROM {table} WHERE {id_column} = $1
UNION ALL
SELECT o.* FROM {table} o JOIN org_tree t ON o.{id_column} = t.{parent_id_column}
)
SELECT * FROM org_tree WHERE {parent_id_column} IS NULL",
table = table,
id_column = id_column,
parent_id_column = parent_id_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(org_id)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn query_org_children(
&self,
parent_id: i32,
) -> Result<Vec<OrganizationModel>, DbAccessError> {
let table = OrganizationColumn::Table.name();
let parent_id_column = OrganizationColumn::ParentId.name();
let sql = format!(
"SELECT * FROM {table} WHERE {parent_id_column} = $1",
table = table,
parent_id_column = parent_id_column
);
let rows = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(parent_id)
.fetch_all(&self.pool)
.await?;
Ok(rows)
}
async fn query_org_name_by_ids(
&self,
ids: Vec<i32>,
) -> Result<Vec<(i32, String)>, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let name_column = OrganizationColumn::Name.name();
let sql = format!(
"SELECT {id_column}, {name_column} FROM {table} WHERE {id_column} = ANY($1)",
id_column = id_column,
name_column = name_column,
table = table
);
let rows: Vec<(i32, String)> = sqlx::query_as(&sql).bind(ids).fetch_all(&self.pool).await?;
Ok(rows)
}
async fn update_org_name(
&self,
id: i32,
name: &str,
updater_id: i32,
) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let name_column = OrganizationColumn::Name.name();
let updater_id_column = OrganizationColumn::UpdaterId.name();
let updated_at_column = OrganizationColumn::UpdatedAt.name();
let sql = format!(
"UPDATE {table} SET {name_column} = $1, {updater_id_column} = $2, {updated_at_column} = 'now()' WHERE {id_column} = $3 RETURNING *",
table = table,
name_column = name_column,
updater_id_column = updater_id_column,
updated_at_column = updated_at_column,
id_column = id_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(name)
.bind(updater_id)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn update_org_config(
&self,
id: i32,
config: Value,
updater_id: i32,
) -> Result<OrganizationModel, DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let config_column = OrganizationColumn::Config.name();
let updater_id_column = OrganizationColumn::UpdaterId.name();
let updated_at_column = OrganizationColumn::UpdatedAt.name();
let sql = format!(
"UPDATE {table} SET {config_column} = $1, {updater_id_column} = $2, {updated_at_column} = 'now()' WHERE {id_column} = $3 RETURNING *",
table = table,
config_column = config_column,
updater_id_column = updater_id_column,
updated_at_column = updated_at_column,
id_column = id_column
);
let row = sqlx::query_as::<_, OrganizationModel>(&sql)
.bind(config)
.bind(updater_id)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(row)
}
async fn delete_org(&self, id: i32) -> Result<(), DbAccessError> {
let table = OrganizationColumn::Table.name();
let id_column = OrganizationColumn::Id.name();
let sql = format!(
"DELETE FROM {table} WHERE {id_column} = $1",
table = table,
id_column = id_column
);
sqlx::query(&sql).bind(id).execute(&self.pool).await?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use sqlx::PgPool;
use super::*;
use crate::{db_access::UserAccessor, model::UserModel, RegisterUser};
async fn init_user(accessor: &RtsaDbAccessor) -> Result<UserModel, DbAccessError> {
let new_user = RegisterUser::new("test_user", "test_password");
let user = accessor.register_user(new_user).await?;
Ok(user)
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_create_org(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
// 初始化用户
let user = init_user(&accessor).await?;
let create = CreateOrg {
parent_id: None,
code: Some("test".to_string()),
name: "测试".to_string(),
config: None,
creator_id: user.id,
};
let org = accessor.create_org(create).await?;
assert_eq!(org.code, Some("test".to_string()));
assert_eq!(org.name, "测试");
assert_eq!(org.creator_id, user.id);
assert_eq!(org.updater_id, user.id);
assert!(org.parent_id.is_none());
assert!(org.config.is_none());
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_is_org_code_exist(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create a new organization
let create = CreateOrg {
parent_id: None,
code: Some("exist_code".to_string()),
name: "存在组织".to_string(),
config: None,
creator_id: user.id,
};
accessor.create_org(create).await?;
// Check if the organization code exists
let exists = accessor.is_org_code_exist("exist_code").await?;
assert!(exists);
// Check for a non-existent code
let not_exists = accessor.is_org_code_exist("nonexistent_code").await?;
assert!(!not_exists);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_get_org_by_code(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create a new organization
let create = CreateOrg {
parent_id: None,
code: Some("get_code_test".to_string()),
name: "通过代码获取组织".to_string(),
config: None,
creator_id: user.id,
};
accessor.create_org(create).await?;
// Retrieve the organization by code
let org = accessor.query_org_by_code("get_code_test").await?;
assert_eq!(org.code, Some("get_code_test".to_string()));
assert_eq!(org.name, "通过代码获取组织");
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_top(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create multiple top-level organizations
for i in 1..4 {
let create = CreateOrg {
parent_id: None,
code: Some(format!("top_org_{}", i)),
name: format!("顶级组织{}", i),
config: None,
creator_id: user.id,
};
let top = accessor.create_org(create).await?;
// Create child organization
let child = CreateOrg {
parent_id: Some(top.id),
code: None,
name: format!("下级组织{}", i),
config: None,
creator_id: user.id,
};
accessor.create_org(child).await?;
}
// Query top-level organizations
let orgs = accessor.query_org_top().await?;
assert_eq!(orgs.len(), 3);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_top_of_org(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create a parent organization
let parent_create = CreateOrg {
parent_id: None,
code: Some("parent_org".to_string()),
name: "父组织".to_string(),
config: None,
creator_id: user.id,
};
let parent_org = accessor.create_org(parent_create).await?;
// Create a child organization
let child_create = CreateOrg::new("一级子组织", user.id).with_parent_id(parent_org.id);
let child = accessor.create_org(child_create).await?;
// Create a grandchild organization
let grandchild_create = CreateOrg::new("二级子组织", user.id).with_parent_id(parent_org.id);
let grandchild = accessor.create_org(grandchild_create).await?;
// Query the top-level organization of the child organization
let top_org = accessor.query_org_top_of_org(grandchild.id).await?;
assert_eq!(top_org.id, parent_org.id);
let top_org = accessor.query_org_top_of_org(child.id).await?;
assert_eq!(top_org.id, parent_org.id);
let top_org = accessor.query_org_top_of_org(parent_org.id).await?;
assert_eq!(top_org.id, parent_org.id);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_children(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create a parent organization
let parent_create = CreateOrg {
parent_id: None,
code: Some("parent_org".to_string()),
name: "父组织".to_string(),
config: None,
creator_id: user.id,
};
let parent_org = accessor.create_org(parent_create).await?;
// Create child organizations
for i in 1..3 {
let create = CreateOrg {
parent_id: Some(parent_org.id),
code: Some(format!("child_org_{}", i)),
name: format!("子组织{}", i),
config: None,
creator_id: user.id,
};
accessor.create_org(create).await?;
}
// Query child organizations
let children = accessor.query_org_children(parent_org.id).await?;
assert_eq!(children.len(), 2);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_update_org_name(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create an organization
let create = CreateOrg {
parent_id: None,
code: Some("update_name_test".to_string()),
name: "旧名称".to_string(),
config: None,
creator_id: user.id,
};
let org = accessor.create_org(create).await?;
// Update the organization's name
let updated_org = accessor.update_org_name(org.id, "新名称", user.id).await?;
assert_eq!(updated_org.name, "新名称");
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_update_org_config(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create an organization
let create = CreateOrg {
parent_id: None,
code: Some("update_config_test".to_string()),
name: "组织配置测试".to_string(),
config: None,
creator_id: user.id,
};
let org = accessor.create_org(create).await?;
// Update the organization's config
let new_config = serde_json::json!({ "key": "value" });
let updated_org = accessor
.update_org_config(org.id, new_config.clone(), user.id)
.await?;
assert_eq!(
updated_org.config,
Some(serde_json::to_value(new_config).unwrap())
);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_delete_org(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create an organization
let create = CreateOrg {
parent_id: None,
code: Some("delete_test".to_string()),
name: "删除组织测试".to_string(),
config: None,
creator_id: user.id,
};
let org = accessor.create_org(create).await?;
// Delete the organization
accessor.delete_org(org.id).await?;
// Attempt to retrieve the deleted organization
let result = accessor.query_org(org.id).await;
assert!(result.is_err());
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_name_by_ids(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let user = init_user(&accessor).await?;
// Create organizations
let mut ids = vec![];
for i in 1..4 {
let create = CreateOrg {
parent_id: None,
code: Some(format!("query_name_test_{}", i)),
name: format!("查询名称{}", i),
config: None,
creator_id: user.id,
};
let org = accessor.create_org(create).await?;
ids.push(org.id);
}
// Query organization names by ids
let names = accessor.query_org_name_by_ids(ids).await?;
assert_eq!(names.len(), 3);
Ok(())
}
}

770
crates/rtsa_db/src/db_access/org_user.rs
View File

@ -1,770 +0,0 @@
use serde_json::Value;
use sqlx::Postgres;
use super::RtsaDbAccessor;
use super::{OrgAccessor, RegisterUser, UserAccessor};
use crate::password_util::verify_password;
use crate::{
common::{PageData, PageQuery, TableColumn},
model::{OrganizationUserColumn, OrganizationUserModel, UserModel},
DbAccessError,
};
/// 组织用户管理
#[allow(async_fn_in_trait)]
pub trait OrgUserAccessor {
/// 创建组织用户
async fn create_org_user(
&self,
create: CreateOrgUser,
) -> Result<(OrganizationUserModel, UserModel), DbAccessError>;
/// 绑定组织用户
async fn bind_org_user(
&self,
bind: BindOrgUser,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 解绑(删除)组织用户
async fn unbind_org_user(&self, org_id: i32, user_id: i32) -> Result<(), DbAccessError>;
/// 删除组织用户
async fn delete_org_user(&self, id: i32) -> Result<(), DbAccessError>;
/// 更新组织用户学工号
async fn update_org_user_student_id(
&self,
id: i32,
student_id: &str,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 更新组织用户角色
async fn update_org_user_roles(
&self,
id: i32,
roles: Value,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 更新组织用户信息
async fn update_org_user_info(
&self,
id: i32,
info: Value,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 查询组织用户登陆
/// username: 学工号/用户名/邮箱/手机号
async fn query_org_user_login(
&self,
org_id: i32,
username: &str,
password: &str,
) -> Result<(OrganizationUserModel, UserModel), DbAccessError>;
/// 获取组织用户
async fn query_org_user(
&self,
org_id: i32,
user_id: i32,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 组织用户是否存在
async fn is_org_user_exist(&self, org_id: i32, user_id: i32) -> Result<bool, DbAccessError>;
/// 获取组织用户
async fn query_org_user_by_student_id(
&self,
org_id: i32,
student_id: &str,
) -> Result<OrganizationUserModel, DbAccessError>;
/// 获取组织用户
async fn query_org_user_by_id(&self, id: i32) -> Result<OrganizationUserModel, DbAccessError>;
/// 分页查询组织用户
async fn query_org_user_page(
&self,
page: PageQuery,
filter: OrgUserFilter,
) -> Result<PageData<OrganizationUserModel>, DbAccessError>;
}
#[derive(Debug, Clone, Default)]
pub struct OrgUserFilter {
pub org_id: Option<i32>,
pub student_id: Option<String>,
}
impl OrgUserFilter {
fn to_where_clause(&self) -> String {
let mut where_clause = vec![];
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let student_id_col = OrganizationUserColumn::StudentId.name();
if let Some(org_id) = self.org_id {
where_clause.push(format!("{org_id_col} = {org_id}"));
}
if let Some(student_id) = &self.student_id {
where_clause.push(format!("{student_id_col} LIKE '%{student_id}%'"));
}
let where_clause = where_clause.join(" AND ");
format!("WHERE {}", where_clause)
}
}
pub struct BindOrgUser {
pub org_id: i32,
pub user_id: i32,
pub student_id: Option<String>,
pub roles: Value,
pub info: Value,
pub creator_id: i32,
}
impl BindOrgUser {
pub fn new(org_id: i32, user_id: i32, creator_id: i32) -> Self {
Self {
org_id,
user_id,
student_id: None,
roles: Value::Array(Default::default()),
info: Value::Object(Default::default()),
creator_id,
}
}
pub fn with_student_id(mut self, student_id: &str) -> Self {
self.student_id = Some(student_id.to_string());
self
}
pub fn with_roles(mut self, roles: Value) -> Self {
self.roles = roles;
self
}
pub fn with_info(mut self, info: Value) -> Self {
self.info = info;
self
}
}
#[derive(Debug, Clone)]
pub struct CreateOrgUser {
pub org_code: String,
pub student_id: String,
pub name: String,
pub password: String,
pub roles: Value,
pub info: Value,
pub email: Option<String>,
pub mobile: Option<String>,
pub creator_id: i32,
}
impl CreateOrgUser {
pub fn new(
org_code: &str,
student_id: &str,
name: &str,
password: &str,
creator_id: i32,
) -> Self {
Self {
org_code: org_code.to_string(),
student_id: student_id.to_string(),
name: name.to_string(),
password: password.to_string(),
roles: Value::Array(Default::default()),
info: Value::Object(Default::default()),
email: None,
mobile: None,
creator_id,
}
}
pub fn nickname(&self) -> String {
self.name.clone()
}
pub fn build_username(&self) -> String {
format!("{}@{}", self.student_id, self.org_code)
}
pub fn with_roles(mut self, roles: Value) -> Self {
self.roles = roles;
self
}
pub fn with_email(mut self, email: String) -> Self {
self.email = Some(email);
self
}
pub fn with_mobile(mut self, mobile: String) -> Self {
self.mobile = Some(mobile);
self
}
}
impl RtsaDbAccessor {
async fn insert_org_user<'e, 'c: 'e, E>(
&self,
bind: BindOrgUser,
executor: E,
) -> Result<OrganizationUserModel, DbAccessError>
where
E: 'e + sqlx::Executor<'c, Database = Postgres>,
{
let table = OrganizationUserColumn::Table.name();
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let user_id_col = OrganizationUserColumn::UserId.name();
let student_id_col = OrganizationUserColumn::StudentId.name();
let roles_col = OrganizationUserColumn::Roles.name();
let info_col = OrganizationUserColumn::Info.name();
let creator_id_col = OrganizationUserColumn::CreatorId.name();
let updater_id_col = OrganizationUserColumn::UpdaterId.name();
let insert_clause = format!(
"INSERT INTO {table} ({org_id_col}, {user_id_col}, {student_id_col}, {roles_col}, {info_col}, {creator_id_col}, {updater_id_col}) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",
);
let insert = sqlx::query_as(&insert_clause)
.bind(bind.org_id)
.bind(bind.user_id)
.bind(bind.student_id)
.bind(bind.roles)
.bind(bind.info)
.bind(bind.creator_id)
.bind(bind.creator_id)
.fetch_one(executor)
.await?;
Ok(insert)
}
}
impl OrgUserAccessor for RtsaDbAccessor {
async fn is_org_user_exist(&self, org_id: i32, user_id: i32) -> Result<bool, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let user_id_col = OrganizationUserColumn::UserId.name();
let query_clause =
format!("SELECT COUNT(*) FROM {table} WHERE {org_id_col} = $1 AND {user_id_col} = $2",);
let count: i64 = sqlx::query_scalar(&query_clause)
.bind(org_id)
.bind(user_id)
.fetch_one(&self.pool)
.await?;
Ok(count > 0)
}
async fn create_org_user(
&self,
create: CreateOrgUser,
) -> Result<(OrganizationUserModel, UserModel), DbAccessError> {
let org = self.query_org_by_code(&create.org_code).await?;
let mut tx = self.pool.begin().await?;
// 检查用户是否存在
let org_user_exist = self.is_user_name_exist(&create.build_username()).await?;
if org_user_exist {
return Err(DbAccessError::RowExist(format!(
"User {} already exists",
create.build_username()
)));
}
// 创建用户
let register = RegisterUser::new(&create.build_username(), &create.password)
.with_nickname(&create.name);
let user = self.insert_user(register, &mut *tx).await?;
// 创建组织用户
let bind = BindOrgUser::new(org.id, user.id, create.creator_id)
.with_student_id(&create.student_id)
.with_roles(create.roles)
.with_info(create.info);
let org_user = self.insert_org_user(bind, &mut *tx).await?;
tx.commit().await?;
Ok((org_user, user))
}
async fn bind_org_user(
&self,
bind: BindOrgUser,
) -> Result<OrganizationUserModel, DbAccessError> {
let org = self.query_org(bind.org_id).await?;
let user = self.query_user(bind.user_id).await?;
// 检查用户是否已绑定
let org_user_exist = self.is_org_user_exist(bind.org_id, bind.user_id).await?;
if org_user_exist {
return Err(DbAccessError::RowExist(format!(
"User {} already bind to organization {}",
user.username, org.name
)));
}
// 创建组织用户
let org_user = self.insert_org_user(bind, &self.pool).await?;
Ok(org_user)
}
async fn unbind_org_user(&self, org_id: i32, user_id: i32) -> Result<(), DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let user_id_col = OrganizationUserColumn::UserId.name();
let delete_clause =
format!("DELETE FROM {table} WHERE {org_id_col} = $1 AND {user_id_col} = $2",);
sqlx::query(&delete_clause)
.bind(org_id)
.bind(user_id)
.execute(&self.pool)
.await?;
Ok(())
}
async fn delete_org_user(&self, id: i32) -> Result<(), DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let id_col = OrganizationUserColumn::Id.name();
let delete_clause = format!("DELETE FROM {table} WHERE {id_col} = $1",);
sqlx::query(&delete_clause)
.bind(id)
.execute(&self.pool)
.await?;
Ok(())
}
async fn update_org_user_student_id(
&self,
id: i32,
student_id: &str,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let id_col = OrganizationUserColumn::Id.name();
let student_id_col = OrganizationUserColumn::StudentId.name();
let updater_id_col = OrganizationUserColumn::UpdaterId.name();
let updated_at_col = OrganizationUserColumn::UpdatedAt.name();
let update_clause =
format!("UPDATE {table} SET {student_id_col} = $1, {updater_id_col} = $2, {updated_at_col} = 'now()' WHERE {id_col} = $3 RETURNING *",);
let update = sqlx::query_as(&update_clause)
.bind(student_id)
.bind(updater_id)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(update)
}
async fn update_org_user_roles(
&self,
id: i32,
roles: Value,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let id_col = OrganizationUserColumn::Id.name();
let roles_col = OrganizationUserColumn::Roles.name();
let updater_id_col = OrganizationUserColumn::UpdaterId.name();
let updated_at_col = OrganizationUserColumn::UpdatedAt.name();
let update_clause =
format!("UPDATE {table} SET {roles_col} = $1, {updater_id_col} = $2, {updated_at_col} = 'now()' WHERE {id_col} = $3 RETURNING *",);
let update = sqlx::query_as(&update_clause)
.bind(roles)
.bind(updater_id)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(update)
}
async fn update_org_user_info(
&self,
id: i32,
info: Value,
updater_id: i32,
) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let id_col = OrganizationUserColumn::Id.name();
let info_col = OrganizationUserColumn::Info.name();
let updater_id_col = OrganizationUserColumn::UpdaterId.name();
let updated_at_col = OrganizationUserColumn::UpdatedAt.name();
let update_clause =
format!("UPDATE {table} SET {info_col} = $1, {updater_id_col} = $2, {updated_at_col} = 'now()' WHERE {id_col} = $3 RETURNING *",);
let update = sqlx::query_as(&update_clause)
.bind(info)
.bind(updater_id)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(update)
}
async fn query_org_user_login(
&self,
org_id: i32,
username: &str,
password: &str,
) -> Result<(OrganizationUserModel, UserModel), DbAccessError> {
// 查询用户登陆
let user = self.query_user_login(username, password).await;
match user {
Err(_) => {
// 用户不存在，查询组织用户学工号+用户密码
// 通过组织id和学工号查询组织用户
let org_user = self.query_org_user_by_student_id(org_id, username).await?;
let user = self.query_user(org_user.user_id).await?;
// 检查用户密码
if verify_password(password, &user.password) {
Ok((org_user, user))
} else {
Err(DbAccessError::InvalidArgument("密码不匹配".to_string()))
}
}
Ok(user) => {
// 用户存在，查询组织用户
let org_user = self.query_org_user(org_id, user.id).await?;
Ok((org_user, user))
}
}
}
async fn query_org_user(
&self,
org_id: i32,
user_id: i32,
) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let user_id_col = OrganizationUserColumn::UserId.name();
let query_clause =
format!("SELECT * FROM {table} WHERE {org_id_col} = $1 AND {user_id_col} = $2",);
let org_user = sqlx::query_as(&query_clause)
.bind(org_id)
.bind(user_id)
.fetch_one(&self.pool)
.await?;
Ok(org_user)
}
async fn query_org_user_by_student_id(
&self,
org_id: i32,
student_id: &str,
) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let org_id_col = OrganizationUserColumn::OrganizationId.name();
let student_id_col = OrganizationUserColumn::StudentId.name();
let query_clause =
format!("SELECT * FROM {table} WHERE {org_id_col} = $1 AND {student_id_col} = $2",);
let org_user = sqlx::query_as(&query_clause)
.bind(org_id)
.bind(student_id)
.fetch_one(&self.pool)
.await?;
Ok(org_user)
}
async fn query_org_user_by_id(&self, id: i32) -> Result<OrganizationUserModel, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let id_col = OrganizationUserColumn::Id.name();
let query_clause = format!("SELECT * FROM {table} WHERE {id_col} = $1",);
let org_user = sqlx::query_as(&query_clause)
.bind(id)
.fetch_one(&self.pool)
.await?;
Ok(org_user)
}
async fn query_org_user_page(
&self,
page: PageQuery,
filter: OrgUserFilter,
) -> Result<PageData<OrganizationUserModel>, DbAccessError> {
let table = OrganizationUserColumn::Table.name();
let where_clause = filter.to_where_clause();
let total_clause = format!("SELECT COUNT(*) FROM {table} {where_clause}",);
let total = sqlx::query_scalar(&total_clause)
.fetch_one(&self.pool)
.await?;
if total == 0 {
return Ok(PageData::new(0, vec![]));
}
let limit_clause = page.to_limit_clause();
let query_clause =
format!("SELECT * FROM {table} {where_clause} ORDER BY id {limit_clause}",);
let query = sqlx::query_as(&query_clause).fetch_all(&self.pool);
let data = query.await?;
Ok(PageData::new(total, data))
}
}
#[cfg(test)]
mod tests {
use serde_json::json;
use sqlx::PgPool;
use super::*;
use crate::{
db_access::UserAccessor,
model::{OrganizationModel, UserModel},
CreateOrg, RegisterUser,
};
const DEFAULT_ORG_CODE: &str = "test_org_code";
const DEFAULT_USER_NAME: &str = "test_user";
const DEFAULT_USER_PASSWORD: &str = "test_password";
async fn init_default_org_and_user(
accessor: &RtsaDbAccessor,
) -> Result<(UserModel, OrganizationModel), DbAccessError> {
let new_user = RegisterUser::new(DEFAULT_USER_NAME, DEFAULT_USER_PASSWORD);
let user = accessor.register_user(new_user).await?;
let new_org = CreateOrg::new("test_org", user.id).with_code(DEFAULT_ORG_CODE);
let org = accessor.create_org(new_org).await?;
Ok((user, org))
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_create_org_user(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (user, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.unwrap(),
"test_student_id",
"test_name",
"test_password",
user.id,
);
let (org_user, new_user) = accessor.create_org_user(create.clone()).await?;
println!("org_user: {:?}", org_user);
println!("new_user: {:?}", new_user);
assert_eq!(org_user.organization_id, org.id);
assert_eq!(org_user.user_id, new_user.id);
assert_eq!(org_user.student_id, Some("test_student_id".to_string()));
assert_eq!(org_user.creator_id, user.id);
assert_eq!(org_user.updater_id, user.id);
assert_eq!(new_user.username, create.build_username());
assert_eq!(new_user.nickname, create.nickname());
assert_eq!(new_user.password, create.password);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_bind_org_user(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
// Create a new user
let register = RegisterUser::new("test_user2", "test_password2");
let new_user = accessor.register_user(register).await?;
// Bind the user to the organization
let bind =
BindOrgUser::new(org.id, new_user.id, creator.id).with_student_id("test_student_id2");
let org_user = accessor.bind_org_user(bind).await?;
assert_eq!(org_user.organization_id, org.id);
assert_eq!(org_user.user_id, new_user.id);
assert_eq!(org_user.student_id, Some("test_student_id2".to_string()));
assert_eq!(org_user.creator_id, creator.id);
assert_eq!(org_user.updater_id, creator.id);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_unbind_org_user(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
// Create and bind a new user
let register = RegisterUser::new("test_user3", "test_password3");
let new_user = accessor.register_user(register).await?;
let bind = BindOrgUser::new(org.id, new_user.id, creator.id);
accessor.bind_org_user(bind).await?;
// Unbind the user from the organization
accessor.unbind_org_user(org.id, new_user.id).await?;
// Verify the user is unbound
let result = accessor.query_org_user(org.id, new_user.id).await;
assert!(matches!(result, Err(DbAccessError::SqlxError(_))));
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_update_org_user_student_id(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"old_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
// Update student ID
let updated_org_user = accessor
.update_org_user_student_id(org_user.id, "new_student_id", creator.id)
.await?;
assert_eq!(
updated_org_user.student_id,
Some("new_student_id".to_string())
);
assert!(updated_org_user.updated_at > org_user.updated_at);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_user_login(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
accessor.create_org_user(create.clone()).await?;
// Attempt to log in with student ID
let (org_user, user) = accessor
.query_org_user_login(org.id, "test_student_id", "test_password")
.await?;
assert_eq!(org_user.organization_id, org.id);
assert_eq!(user.nickname, create.nickname());
// Attempt to log in with username
let (org_user, user) = accessor
.query_org_user_login(org.id, &create.build_username(), "test_password")
.await?;
assert_eq!(org_user.organization_id, org.id);
assert_eq!(user.nickname, create.nickname());
// Attempt to log in with wrong password
let result = accessor
.query_org_user_login(org.id, "test_student_id", "wrong_password")
.await;
assert!(matches!(result, Err(DbAccessError::InvalidArgument(_))));
// Attempt to log in with wrong username
let result = accessor
.query_org_user_login(org.id, "wrong_student_id", "test_password")
.await;
assert!(matches!(result, Err(DbAccessError::SqlxError(_))));
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_user_by_student_id(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
let result = accessor
.query_org_user_by_student_id(org.id, "test_student_id")
.await?;
assert_eq!(result, org_user);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_user_by_id(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
let result = accessor.query_org_user_by_id(org_user.id).await?;
assert_eq!(result, org_user);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_query_org_user_page(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
accessor.create_org_user(create).await?;
let page = PageQuery::new(1, 10);
let filter = OrgUserFilter {
org_id: Some(org.id),
student_id: None,
};
let result = accessor.query_org_user_page(page, filter).await?;
assert_eq!(result.total, 1);
assert_eq!(result.data.len(), 1);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_is_org_user_exist(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (_, new_user) = accessor.create_org_user(create).await?;
let result = accessor.is_org_user_exist(org.id, new_user.id).await?;
assert!(result);
let result = accessor.is_org_user_exist(org.id, 0).await?;
assert!(!result);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_update_org_user_roles(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
let roles = json!(["role1", "role2"]);
let updated_org_user = accessor
.update_org_user_roles(org_user.id, roles.clone(), creator.id)
.await?;
assert_eq!(updated_org_user.roles, roles);
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_update_org_user_info(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
let info = json!({"key": "value"});
let updated_org_user = accessor
.update_org_user_info(org_user.id, info.clone(), creator.id)
.await?;
assert_eq!(updated_org_user.info, Some(info));
Ok(())
}
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_delete_org_user(pool: PgPool) -> Result<(), DbAccessError> {
let accessor = RtsaDbAccessor::new(pool);
let (creator, org) = init_default_org_and_user(&accessor).await?;
let create = CreateOrgUser::new(
&org.code.clone().unwrap(),
"test_student_id",
"test_name",
"test_password",
creator.id,
);
let (org_user, _) = accessor.create_org_user(create).await?;
accessor.delete_org_user(org_user.id).await?;
let result = accessor.query_org_user_by_id(org_user.id).await;
assert!(matches!(result, Err(DbAccessError::SqlxError(_))));
Ok(())
}
}

123
crates/rtsa_db/src/db_access/release_data.rs
View File

@ -1,8 +1,9 @@
use rtsa_dto::common::DataType;
use serde_json::Value;
use sqlx::{types::chrono, Postgres};
use crate::{
common::{PageData, PageQuery, Sort, SortOrder, TableColumn},
common::{PageQuery, PageResult, Sort, SortOrder, TableColumn},
model::{
DraftDataModel, ReleaseDataColumn, ReleaseDataModel, ReleaseDataVersionColumn,
ReleaseDataVersionModel,
@ -34,11 +35,11 @@ pub trait ReleaseDataAccessor {
&self,
query: ReleaseDataQuery,
page: PageQuery,
) -> Result<PageData<ReleaseDataModel>, DbAccessError>;
) -> Result<PageResult<ReleaseDataModel>, DbAccessError>;
/// 检查name是否存在
async fn is_release_data_name_exist(
&self,
data_type: i32,
data_type: DataType,
name: &str,
) -> Result<bool, DbAccessError>;
/// 查询发布数据
@ -56,7 +57,7 @@ pub trait ReleaseDataAccessor {
&self,
release_id: i32,
page: PageQuery,
) -> Result<PageData<ReleaseDataVersionModel>, DbAccessError>;
) -> Result<PageResult<ReleaseDataVersionModel>, DbAccessError>;
/// 根据id查询发布版本数据
async fn query_release_data_version_by_id(
&self,
@ -108,7 +109,7 @@ pub struct ReleaseFromDraftResult {
pub struct ReleaseDataQuery {
pub name: Option<String>,
pub user_id: Option<i32>,
pub data_type: Option<i32>,
pub data_type: Option<rtsa_dto::common::DataType>,
pub options: Option<Value>,
pub is_published: Option<bool>,
}
@ -140,7 +141,7 @@ impl ReleaseDataQuery {
self
}
pub fn with_data_type(mut self, data_type: i32) -> Self {
pub fn with_data_type(mut self, data_type: rtsa_dto::common::DataType) -> Self {
self.data_type = Some(data_type);
self
}
@ -173,7 +174,7 @@ impl ReleaseDataQuery {
filters.push(format!("{rd_user_id} = {user_id}"));
}
if let Some(data_type) = self.data_type {
filters.push(format!("{rd_data_type} = {}", data_type));
filters.push(format!("{rd_data_type} = {}", data_type as i32));
}
if let Some(options) = &self.options {
let options_column = ReleaseDataColumn::Options.name();
@ -367,7 +368,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
&self,
query: ReleaseDataQuery,
page: PageQuery,
) -> Result<PageData<ReleaseDataModel>, DbAccessError> {
) -> Result<PageResult<ReleaseDataModel>, DbAccessError> {
let rd_table = ReleaseDataColumn::Table.name();
let where_clause = query.build_filter();
let count_clause = format!("SELECT COUNT(*) FROM {rd_table} {where_clause}");
@ -377,7 +378,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
.fetch_one(&self.pool)
.await?;
if total == 0 {
return Ok(PageData::new(0, vec![]));
return Ok(PageResult::new(0, vec![]));
}
let paging_clause = page.to_limit_clause();
let order_by = Sort::new(ReleaseDataColumn::UpdatedAt, SortOrder::Desc);
@ -387,12 +388,12 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
let data = sqlx::query_as::<_, ReleaseDataModel>(&query_clause)
.fetch_all(&self.pool)
.await?;
Ok(PageData::new(total, data))
Ok(PageResult::new(total, data))
}
async fn is_release_data_name_exist(
&self,
data_type: i32,
data_type: DataType,
name: &str,
) -> Result<bool, DbAccessError> {
let rd_table = ReleaseDataColumn::Table.name();
@ -405,7 +406,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
);
let count: i64 = sqlx::query_scalar(&rd_query_clause)
.bind(name)
.bind(data_type)
.bind(data_type as i32)
.fetch_one(&self.pool)
.await?;
Ok(count > 0)
@ -452,7 +453,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
&self,
release_id: i32,
page: PageQuery,
) -> Result<PageData<ReleaseDataVersionModel>, DbAccessError> {
) -> Result<PageResult<ReleaseDataVersionModel>, DbAccessError> {
// 查询发布数据版本
let rdv_table = ReleaseDataVersionColumn::Table.name();
let rdv_release_id = ReleaseDataVersionColumn::ReleaseDataId.name();
@ -465,7 +466,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
.fetch_one(&self.pool)
.await?;
if total == 0 {
return Ok(PageData::new(0, vec![]));
return Ok(PageResult::new(0, vec![]));
}
// 查询列，除了data列
let rdv_columns = format!(
@ -489,7 +490,7 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
.bind(release_id)
.fetch_all(&self.pool)
.await?;
Ok(PageData::new(total, data))
Ok(PageResult::new(total, data))
}
async fn query_release_data_version_by_id(
@ -644,63 +645,15 @@ impl ReleaseDataAccessor for RtsaDbAccessor {
#[cfg(test)]
mod tests {
use crate::{CreateDraftData, DraftDataAccessor, RegisterUser, RtsaDbAccessor, UserAccessor};
use crate::{CreateDraftData, DraftDataAccessor, RtsaDbAccessor, SyncUserInfo, UserAccessor};
use super::*;
use chrono::Local;
use rtsa_dto::common::{IscsStyle, Role};
use rtsa_log::tracing::Level;
use serde::{Deserialize, Serialize};
use sqlx::PgPool;
/// 数据类型
#[derive(
sqlx::Type,
serde::Serialize,
serde::Deserialize,
Clone,
Copy,
Debug,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
)]
#[repr(i32)]
pub enum DataType {
/// 数据类型未知
Unknown = 0,
/// 电子地图数据
Em = 1,
/// ISCS数据
Iscs = 4,
}
/// 数据类型
#[derive(
sqlx::Type,
serde::Serialize,
serde::Deserialize,
Clone,
Copy,
Debug,
PartialEq,
Eq,
Hash,
PartialOrd,
Ord,
)]
#[repr(i32)]
pub enum IscsStyle {
/// 数据类型未知
Unknown = 0,
/// 电子地图数据
Style1 = 1,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IscsDataOptions {
pub style: IscsStyle,
}
#[test]
fn test_release_query() {
// 测试构造发布数据查询条件，名称过滤
@ -715,7 +668,7 @@ mod tests {
// 测试构造发布数据查询条件，数据类型过滤
let expects = "WHERE data_type = 1";
let query_with_data_type = ReleaseDataQuery::new().with_data_type(DataType::Em as i32);
let query_with_data_type = ReleaseDataQuery::new().with_data_type(DataType::Em);
assert_eq!(query_with_data_type.build_filter(), expects);
// 测试构造发布数据查询条件，是否上架过滤
@ -729,29 +682,45 @@ mod tests {
let query_with_all = ReleaseDataQuery::new()
.with_name("test".to_string())
.with_user_id(1)
.with_data_type(DataType::Em as i32)
.with_data_type(DataType::Em)
.with_is_published(true);
assert_eq!(query_with_all.build_filter(), expects);
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IscsDataOptions {
pub style: IscsStyle,
}
// You could also do `use foo_crate::MIGRATOR` and just refer to it as `MIGRATOR` here.
#[sqlx::test(migrator = "crate::MIGRATOR")]
async fn test_basic_use(pool: PgPool) -> Result<(), DbAccessError> {
rtsa_log::Logging::default().with_level(Level::DEBUG).init();
let accessor = RtsaDbAccessor::new(pool);
// 注册10个用户
// 同步10个用户
let mut users = vec![];
for i in 0..10 {
let user = RegisterUser::new(&format!("test{}", i), "123456");
accessor.register_user(user).await?;
let user = SyncUserInfo {
id: i + 1,
name: format!("user{}", i + 1),
password: "password".to_string(),
roles: serde_json::to_value(vec![Role::User]).unwrap(),
email: None,
mobile: None,
created_at: Local::now(),
updated_at: None,
};
users.push(user);
}
accessor.sync_user(users.as_slice()).await?;
// 创建草稿
let data = "test".as_bytes();
let draft = accessor
.create_draft_data(
CreateDraftData::new("test", rtsa_dto::common::DataType::Iscs as i32, 1)
CreateDraftData::new("test", rtsa_dto::common::DataType::Iscs, 1)
.with_options(
serde_json::to_value(IscsDataOptions {
style: IscsStyle::Style1,
style: IscsStyle::DaShiZhiNeng,
})
.unwrap(),
)
@ -784,7 +753,7 @@ mod tests {
// 检查options数据
let options: IscsDataOptions =
serde_json::from_value(release_data.options.unwrap()).unwrap();
assert_eq!(options.style, IscsStyle::Style1);
assert_eq!(options.style, IscsStyle::DaShiZhiNeng);
// 检查版本数据
assert_eq!(version1.data, data);
// 检查版本描述
@ -798,7 +767,7 @@ mod tests {
// name重复检查
let exist = accessor
.is_release_data_name_exist(DataType::Iscs as i32, name)
.is_release_data_name_exist(rtsa_dto::common::DataType::Iscs, name)
.await?;
assert!(exist);
@ -880,7 +849,7 @@ mod tests {
let data = "test data".as_bytes();
let draft = accessor
.create_draft_data(
CreateDraftData::new(&name, DataType::Em as i32, i).with_data(data),
CreateDraftData::new(&name, rtsa_dto::common::DataType::Em, i).with_data(data),
)
.await?;
let (release_data, _) = accessor
@ -914,7 +883,7 @@ mod tests {
let page_result = accessor.paging_query_release_data_list(query, page).await?;
assert_eq!(page_result.total, 2);
// 分页查询发布数据，按数据类型过滤
let query = ReleaseDataQuery::new().with_data_type(DataType::Em as i32);
let query = ReleaseDataQuery::new().with_data_type(rtsa_dto::common::DataType::Em);
let page = PageQuery::new(1, 10);
let page_result = accessor.paging_query_release_data_list(query, page).await?;
assert_eq!(page_result.total, 8);

1028
crates/rtsa_db/src/db_access/user.rs
View File

File diff suppressed because it is too large Load Diff

10
crates/rtsa_db/src/error.rs
View File

@ -3,15 +3,11 @@ use thiserror::Error;
#[derive(Error, Debug)]
pub enum DbAccessError {
#[error("未知的数据库访问错误")]
Unknown(#[from] anyhow::Error),
Unknown,
#[error("数据访问错误: {0}")]
SqlxError(#[from] sqlx::Error),
#[error("数据已存在: {0}")]
RowExist(String),
#[error("数据不存在: {0}")]
RowNotExist(String),
#[error("数据已存在")]
RowExist,
#[error("数据错误：{0}")]
DataError(String),
#[error("非法参数：{0}")]
InvalidArgument(String),
}

3
crates/rtsa_db/src/lib.rs
View File

@ -4,8 +4,6 @@ mod error;
pub mod model;
pub use db_access::*;
pub use error::*;
pub mod password_util;
pub mod username_util;
use sqlx::pool::PoolOptions;
pub use sqlx::types::chrono::*;
@ -25,6 +23,5 @@ pub mod prelude {
pub use crate::common::*;
pub use crate::db_access::*;
pub use crate::model::*;
pub use crate::password_util::*;
pub use crate::DbAccessError;
}

372
crates/rtsa_db/src/model.rs
View File

@ -1,5 +1,9 @@
use rtsa_dto::common::{DataType, FeatureType, Role};
use serde_json::Value;
use sqlx::types::chrono::{DateTime, Local};
use sqlx::types::{
chrono::{DateTime, Local},
Json,
};
use crate::common::TableColumn;
@ -21,11 +25,9 @@ pub enum UserColumn {
Id,
Username,
Password,
Nickname,
Email,
Mobile,
Roles,
Info,
CreatedAt,
UpdatedAt,
}
@ -35,182 +37,15 @@ pub struct UserModel {
pub id: i32,
pub username: String,
pub password: String,
pub nickname: String,
#[sqlx(default)]
pub email: Option<String>,
#[sqlx(default)]
pub mobile: Option<String>,
pub roles: Value,
pub info: Value,
pub roles: Json<Vec<Role>>,
pub created_at: DateTime<Local>,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.user_data 列映射
#[derive(Debug)]
pub enum UserDataColumn {
Table,
Id,
UserId,
DataType,
Data,
CreatedAt,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct UserDataModel {
pub id: i32,
pub user_id: i32,
pub data_type: i32,
pub data: Value,
pub created_at: DateTime<Local>,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.organization 列映射
#[derive(Debug)]
pub enum OrganizationColumn {
Table,
Id,
Code,
Name,
Config,
ParentId,
CreatorId,
CreatedAt,
UpdaterId,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct OrganizationModel {
pub id: i32,
pub code: Option<String>,
pub name: String,
#[sqlx(default)]
pub config: Option<Value>,
pub parent_id: Option<i32>,
pub creator_id: i32,
pub created_at: DateTime<Local>,
pub updater_id: i32,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.organization_user 列映射
#[derive(Debug)]
pub enum OrganizationUserColumn {
Table,
Id,
OrganizationId,
UserId,
StudentId,
Roles,
Info,
CreatorId,
CreatedAt,
UpdaterId,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow, Clone, PartialEq, Eq)]
pub struct OrganizationUserModel {
pub id: i32,
pub organization_id: i32,
pub user_id: i32,
pub student_id: Option<String>,
pub roles: Value,
pub info: Option<Value>,
pub creator_id: i32,
pub created_at: DateTime<Local>,
pub updater_id: i32,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.organization_data 列映射
#[derive(Debug)]
pub enum OrganizationDataColumn {
Table,
Id,
OrganizationId,
DataType,
Data,
CreatorId,
CreatedAt,
UpdaterId,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct OrganizationDataModel {
pub id: i32,
pub organization_id: i32,
pub data_type: i32,
pub data: Value,
pub creator_id: i32,
pub created_at: DateTime<Local>,
pub updater_id: i32,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.feature 列映射
#[derive(Debug)]
#[allow(dead_code)]
pub enum FeatureColumn {
Table,
Id,
FeatureType,
Name,
Description,
Config,
IsPublished,
CreatorId,
UpdaterId,
CreatedAt,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct FeatureModel {
pub id: i32,
pub feature_type: i32,
pub name: String,
pub description: String,
#[sqlx(default)]
pub config: Value,
pub is_published: bool,
pub creator_id: i32,
pub updater_id: i32,
pub created_at: DateTime<Local>,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.organization_feature 列映射
#[derive(Debug)]
pub enum OrganizationFeatureColumn {
Table,
Id,
OrganizationId,
FeatureId,
Config,
CreatorId,
CreatedAt,
UpdaterId,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct OrganizationFeatureModel {
pub id: i32,
pub organization_id: i32,
pub feature_id: i32,
pub config: Value,
pub creator_id: i32,
pub created_at: DateTime<Local>,
pub updater_id: i32,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.draft_data 列映射
#[derive(Debug)]
pub enum DraftDataColumn {
@ -231,7 +66,7 @@ pub enum DraftDataColumn {
pub struct DraftDataModel {
pub id: i32,
pub name: String,
pub data_type: i32,
pub data_type: DataType,
#[sqlx(default)]
pub options: Option<Value>,
#[sqlx(default)]
@ -265,7 +100,7 @@ pub enum ReleaseDataColumn {
pub struct ReleaseDataModel {
pub id: i32,
pub name: String,
pub data_type: i32,
pub data_type: DataType,
/// 从发布版本复制的选项，主要用于查询
#[sqlx(default)]
pub options: Option<Value>,
@ -302,75 +137,59 @@ pub struct ReleaseDataVersionModel {
pub created_at: DateTime<Local>,
}
/// 数据库表 rtsa.release_data_set 列映射
/// 数据库表 rtsa.feature 列映射
#[derive(Debug)]
pub enum ReleaseDataSetColumn {
#[allow(dead_code)]
pub enum FeatureColumn {
Table,
Id,
DataSetType,
FeatureType,
Name,
Description,
Config,
IsPublished,
CreatorId,
CreatedAt,
UpdaterId,
CreatedAt,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct ReleaseDataSetModel {
pub struct FeatureModel {
pub id: i32,
pub data_set_type: i32,
pub feature_type: FeatureType,
pub name: String,
pub description: String,
#[sqlx(default)]
pub config: Value,
pub is_published: bool,
pub creator_id: i32,
pub created_at: DateTime<Local>,
pub updater_id: i32,
pub created_at: DateTime<Local>,
pub updated_at: DateTime<Local>,
}
/// 数据库表 rtsa.release_data_set_data 列映射
/// 数据库表 rtsa.user_config 列映射
#[derive(Debug)]
pub enum ReleaseDataSetDataColumn {
#[allow(dead_code)]
pub enum UserConfigColumn {
Table,
Id,
ReleaseDataSetId,
ReleaseDataId,
OrderIndex,
}
#[derive(Debug, sqlx::FromRow)]
pub struct ReleaseDataSetDataModel {
pub id: i32,
pub release_data_set_id: i32,
pub release_data_id: i32,
pub order_index: i32,
}
/// 数据库表 rtsa.user_operation_log 列映射
#[derive(Debug)]
pub enum UserOperationLogColumn {
Table,
Id,
OrganizationId,
UserId,
LogType,
LogData,
ConfigType,
Config,
CreatedAt,
UpdatedAt,
}
#[derive(Debug, sqlx::FromRow)]
pub struct UserOperationLogModel {
pub struct UserConfigModel {
pub id: i32,
pub organization_id: i32,
pub user_id: i32,
pub log_type: i32,
pub log_data: Value,
pub config_type: i32,
pub config: Value,
pub created_at: DateTime<Local>,
pub updated_at: DateTime<Local>,
}
impl TableColumn for UserColumn {
@ -380,116 +199,15 @@ impl TableColumn for UserColumn {
UserColumn::Id => "id",
UserColumn::Username => "username",
UserColumn::Password => "password",
UserColumn::Nickname => "nickname",
UserColumn::Email => "email",
UserColumn::Mobile => "mobile",
UserColumn::Roles => "roles",
UserColumn::Info => "info",
UserColumn::CreatedAt => "created_at",
UserColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for UserDataColumn {
fn name(&self) -> &str {
match self {
UserDataColumn::Table => "rtsa.user_data",
UserDataColumn::Id => "id",
UserDataColumn::UserId => "user_id",
UserDataColumn::DataType => "data_type",
UserDataColumn::Data => "data",
UserDataColumn::CreatedAt => "created_at",
UserDataColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for OrganizationColumn {
fn name(&self) -> &str {
match self {
OrganizationColumn::Table => "rtsa.organization",
OrganizationColumn::Id => "id",
OrganizationColumn::Code => "code",
OrganizationColumn::Name => "name",
OrganizationColumn::Config => "config",
OrganizationColumn::ParentId => "parent_id",
OrganizationColumn::CreatorId => "creator_id",
OrganizationColumn::CreatedAt => "created_at",
OrganizationColumn::UpdaterId => "updater_id",
OrganizationColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for OrganizationUserColumn {
fn name(&self) -> &str {
match self {
OrganizationUserColumn::Table => "rtsa.organization_user",
OrganizationUserColumn::Id => "id",
OrganizationUserColumn::OrganizationId => "organization_id",
OrganizationUserColumn::UserId => "user_id",
OrganizationUserColumn::StudentId => "student_id",
OrganizationUserColumn::Roles => "roles",
OrganizationUserColumn::Info => "info",
OrganizationUserColumn::CreatorId => "creator_id",
OrganizationUserColumn::CreatedAt => "created_at",
OrganizationUserColumn::UpdaterId => "updater_id",
OrganizationUserColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for OrganizationDataColumn {
fn name(&self) -> &str {
match self {
OrganizationDataColumn::Table => "rtsa.organization_data",
OrganizationDataColumn::Id => "id",
OrganizationDataColumn::OrganizationId => "organization_id",
OrganizationDataColumn::DataType => "data_type",
OrganizationDataColumn::Data => "data",
OrganizationDataColumn::CreatorId => "creator_id",
OrganizationDataColumn::CreatedAt => "created_at",
OrganizationDataColumn::UpdaterId => "updater_id",
OrganizationDataColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for FeatureColumn {
fn name(&self) -> &str {
match self {
FeatureColumn::Table => "rtsa.feature",
FeatureColumn::Id => "id",
FeatureColumn::FeatureType => "feature_type",
FeatureColumn::Name => "name",
FeatureColumn::Description => "description",
FeatureColumn::Config => "config",
FeatureColumn::IsPublished => "is_published",
FeatureColumn::CreatorId => "creator_id",
FeatureColumn::UpdaterId => "updater_id",
FeatureColumn::CreatedAt => "created_at",
FeatureColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for OrganizationFeatureColumn {
fn name(&self) -> &str {
match self {
OrganizationFeatureColumn::Table => "rtsa.organization_feature",
OrganizationFeatureColumn::Id => "id",
OrganizationFeatureColumn::OrganizationId => "organization_id",
OrganizationFeatureColumn::FeatureId => "feature_id",
OrganizationFeatureColumn::Config => "config",
OrganizationFeatureColumn::CreatorId => "creator_id",
OrganizationFeatureColumn::CreatedAt => "created_at",
OrganizationFeatureColumn::UpdaterId => "updater_id",
OrganizationFeatureColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for DraftDataColumn {
fn name(&self) -> &str {
match self {
@ -540,32 +258,34 @@ impl TableColumn for ReleaseDataVersionColumn {
}
}
impl TableColumn for ReleaseDataSetColumn {
impl TableColumn for FeatureColumn {
fn name(&self) -> &str {
match self {
ReleaseDataSetColumn::Table => "rtsa.release_data_set",
ReleaseDataSetColumn::Id => "id",
ReleaseDataSetColumn::DataSetType => "data_set_type",
ReleaseDataSetColumn::Name => "name",
ReleaseDataSetColumn::Description => "description",
ReleaseDataSetColumn::Config => "config",
ReleaseDataSetColumn::IsPublished => "is_published",
ReleaseDataSetColumn::CreatorId => "creator_id",
ReleaseDataSetColumn::CreatedAt => "created_at",
ReleaseDataSetColumn::UpdaterId => "updater_id",
ReleaseDataSetColumn::UpdatedAt => "updated_at",
FeatureColumn::Table => "rtsa.feature",
FeatureColumn::Id => "id",
FeatureColumn::FeatureType => "feature_type",
FeatureColumn::Name => "name",
FeatureColumn::Description => "description",
FeatureColumn::Config => "config",
FeatureColumn::IsPublished => "is_published",
FeatureColumn::CreatorId => "creator_id",
FeatureColumn::UpdaterId => "updater_id",
FeatureColumn::CreatedAt => "created_at",
FeatureColumn::UpdatedAt => "updated_at",
}
}
}
impl TableColumn for ReleaseDataSetDataColumn {
impl TableColumn for UserConfigColumn {
fn name(&self) -> &str {
match self {
ReleaseDataSetDataColumn::Table => "rtsa.release_data_set_data",
ReleaseDataSetDataColumn::Id => "id",
ReleaseDataSetDataColumn::ReleaseDataSetId => "release_data_set_id",
ReleaseDataSetDataColumn::ReleaseDataId => "release_data_id",
ReleaseDataSetDataColumn::OrderIndex => "order_index",
UserConfigColumn::Table => "rtsa.user_config",
UserConfigColumn::Id => "id",
UserConfigColumn::UserId => "user_id",
UserConfigColumn::ConfigType => "config_type",
UserConfigColumn::Config => "config",
UserConfigColumn::CreatedAt => "created_at",
UserConfigColumn::UpdatedAt => "updated_at",
}
}
}

4
crates/rtsa_db/src/password_util.rs
View File

@ -1,4 +0,0 @@
/// 验证密码是否正确
pub fn verify_password(password: &str, hash: &str) -> bool {
password == hash
}

53
crates/rtsa_db/src/username_util.rs
View File

@ -1,53 +0,0 @@
use lazy_static::lazy_static;
use regex::Regex;
pub fn is_email(email: &str) -> bool {
lazy_static! {
static ref RE: Regex =
Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
}
RE.is_match(email)
}
pub fn is_mobile(mobile: &str) -> bool {
lazy_static! {
static ref RE: Regex = Regex::new(r"^1[3-9]\d{9}$").unwrap();
}
RE.is_match(mobile)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_is_email() {
assert!(!is_email("test"));
assert!(!is_email("test@"));
assert!(!is_email("test@163"));
assert!(!is_email("test@163."));
assert!(!is_email("test@163.c"));
assert!(is_email("test@163.cn"));
}
#[test]
fn test_is_mobile() {
assert!(!is_mobile("test"));
assert!(!is_mobile("12345678901"));
assert!(!is_mobile("22345678901"));
assert!(!is_mobile("32345678901"));
assert!(!is_mobile("42345678901"));
assert!(!is_mobile("52345678901"));
assert!(!is_mobile("62345678901"));
assert!(!is_mobile("72345678901"));
assert!(!is_mobile("82345678901"));
assert!(!is_mobile("92345678901"));
assert!(is_mobile("13345678901"));
assert!(is_mobile("14345678901"));
assert!(is_mobile("15345678901"));
assert!(is_mobile("16345678901"));
assert!(is_mobile("17345678901"));
assert!(is_mobile("18345678901"));
assert!(is_mobile("19345678901"));
}
}

17
crates/rtsa_dto/src/pb/common.rs
View File

@ -112,15 +112,6 @@ pub enum Role {
Admin = 1,
/// 普通用户
User = 2,
/// -----组织用户角色-----
/// 组织管理员
OrgManager = 11,
/// 组织教师
OrgTeacher = 12,
/// 组织学生
OrgStudent = 13,
/// 组织访客
OrgGuest = 14,
}
impl Role {
/// String value of the enum field names used in the ProtoBuf definition.
@ -132,10 +123,6 @@ impl Role {
Role::Unknown => "Role_Unknown",
Role::Admin => "Role_Admin",
Role::User => "Role_User",
Role::OrgManager => "Role_OrgManager",
Role::OrgTeacher => "Role_OrgTeacher",
Role::OrgStudent => "Role_OrgStudent",
Role::OrgGuest => "Role_OrgGuest",
}
}
/// Creates an enum from field names used in the ProtoBuf definition.
@ -144,10 +131,6 @@ impl Role {
"Role_Unknown" => Some(Self::Unknown),
"Role_Admin" => Some(Self::Admin),
"Role_User" => Some(Self::User),
"Role_OrgManager" => Some(Self::OrgManager),
"Role_OrgTeacher" => Some(Self::OrgTeacher),
"Role_OrgStudent" => Some(Self::OrgStudent),
"Role_OrgGuest" => Some(Self::OrgGuest),
_ => None,
}
}

30
manager/Cargo.toml
View File

@ -4,36 +4,12 @@ version = "0.1.0"
edition = "2021"
[dependencies]
rtsa_log = { path = "../crates/rtsa_log" }
rtsa_db = { path = "../crates/rtsa_db" }
rtsa_dto = { path = "../crates/rtsa_dto" }
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
rtsa_log = { path = "../crates/rtsa_log" }
rtsa_api = { path = "crates/rtsa_api" }
rtsa_db = { path = "../crates/rtsa_db" }
serde = { workspace = true }
serde_json = { workspace = true }
config = { workspace = true }
clap = { workspace = true, features = ["derive"] }
enum_dispatch = { workspace = true }
anyhow = { workspace = true }
thiserror = { workspace = true }
chrono = { version = "0.4.38", features = ["serde"] }
axum = "0.7.5"
axum-extra = { version = "0.9.3", features = ["typed-header"] }
jsonwebtoken = "9.3.0"
tower-http = { version = "0.6.0", features = ["cors"] }
async-graphql = { version = "7.0.7", features = ["chrono", "dataloader"] }
async-graphql-axum = "7.0.6"
base64 = "0.22.1"
sysinfo = "0.31.3"
reqwest = { version = "0.12.7", default-features = false, features = ["rustls-tls", "json"] }
[dev-dependencies]
sqlx = { workspace = true, features = [
"runtime-tokio",
"macros",
"chrono",
"json",
"derive",
"postgres",
"uuid",
] }

7
manager/conf/default.toml
View File

@ -5,3 +5,10 @@ port = 8765
[log]
level = "debug"
[sso]
base_url = "http://localhost:8080"
login_url = "/api/login"
logout_url = "/api/login/logout"
user_info_url = "/api/login/getUserInfo"
sync_user_url = "/api/userinfo/list/all"

3
manager/conf/dev.toml
View File

@ -1,2 +1,5 @@
[database]
url = "postgresql://joylink:Joylink@0503@localhost:5432/joylink"
[sso]
base_url = "http://192.168.33.233/rtss-server"

3
manager/conf/local_test.toml
View File

@ -3,3 +3,6 @@ url = "postgresql://joylink:Joylink@0503@10.11.11.2:5432/joylink"
[log]
level = "debug"
[sso]
base_url = "http://192.168.33.233/rtss-server"

24
manager/crates/rtsa_api/Cargo.toml Normal file
View File

@ -0,0 +1,24 @@
[package]
name = "rtsa_api"
version = "0.1.0"
edition = "2021"
[dependencies]
anyhow = { workspace = true }
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
chrono = { version = "0.4.38", features = ["serde"] }
axum = "0.7.5"
axum-extra = { version = "0.9.3", features = ["typed-header"] }
jsonwebtoken = "9.3.0"
tower-http = { version = "0.6.0", features = ["cors"] }
async-graphql = { version = "7.0.7", features = ["chrono", "dataloader"] }
async-graphql-axum = "7.0.6"
base64 = "0.22.1"
sysinfo = "0.31.3"
reqwest = { version = "0.12.7", default-features = false, features = ["rustls-tls", "json"] }
rtsa_log = { path = "../../../crates/rtsa_log" }
rtsa_db = { path = "../../../crates/rtsa_db" }
rtsa_dto = { path = "../../../crates/rtsa_dto" }

0
manager/src/apis/data_options_def.rs → manager/crates/rtsa_api/src/apis/data_options_def.rs
View File

40
manager/src/apis/draft_data.rs → manager/crates/rtsa_api/src/apis/draft_data.rs
View File

@ -15,7 +15,7 @@ use super::data_options_def::{DataOptions, IscsDataOptions};
use super::release_data::ReleaseDataId;
use super::user::UserId;
use crate::user_auth::{Jwt, RoleGuard};
use crate::user_auth::{RoleGuard, Token, UserAuthCache};
#[derive(Default)]
pub struct DraftDataQuery;
@ -47,8 +47,11 @@ impl DraftDataQuery {
paging: PageQueryDto,
mut query: UserDraftDataFilterDto<IscsDataOptions>,
) -> async_graphql::Result<PageDto<DraftIscsDataDto>> {
let claims = ctx.data::<Jwt>()?.decode()?;
query.user_id = claims.uid;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
query.user_id = user.id_i32();
query.data_type = Some(DataType::Iscs);
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let paging_result = db_accessor
@ -86,11 +89,14 @@ impl DraftDataQuery {
data_type: DataType,
name: String,
) -> async_graphql::Result<bool> {
let claims = ctx.data::<Jwt>()?.decode()?;
let user_id = claims.uid;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let user_id = user.id_i32();
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let exist = db_accessor
.is_draft_data_exist(user_id, data_type as i32, &name)
.is_draft_data_exist(user_id, &data_type, &name)
.await?;
Ok(exist)
}
@ -105,8 +111,11 @@ impl DraftDataMutation {
ctx: &Context<'_>,
mut input: CreateDraftDataDto<IscsDataOptions>,
) -> async_graphql::Result<DraftIscsDataDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
input = input.with_data_type_and_user_id(DataType::Iscs, claims.uid);
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
input = input.with_data_type_and_user_id(DataType::Iscs, user.id_i32());
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let draft_data = db_accessor.create_draft_data(input.into()).await?;
Ok(draft_data.into())
@ -184,8 +193,11 @@ impl DraftDataMutation {
id: i32,
name: String,
) -> async_graphql::Result<DraftDataDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let user_id = claims.uid;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let user_id = user.id_i32();
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let draft_data = db_accessor.save_as_new_draft(id, &name, user_id).await?;
Ok(draft_data.into())
@ -215,7 +227,7 @@ impl<T: DataOptions> From<CreateDraftDataDto<T>> for rtsa_db::CreateDraftData {
fn from(value: CreateDraftDataDto<T>) -> Self {
let cdd = Self::new(
&value.name,
value.data_type.expect("need data_type") as i32,
value.data_type.expect("need data_type"),
value.user_id.expect("CreateDraftDataDto need user_id"),
);
if value.options.is_some() {
@ -244,7 +256,7 @@ impl<T: DataOptions> From<UserDraftDataFilterDto<T>> for rtsa_db::DraftDataQuery
Self {
user_id: Some(value.user_id),
name: value.name,
data_type: value.data_type.map(|dt| dt as i32),
data_type: value.data_type,
options: value.options.map(|o| serde_json::to_value(o).unwrap()),
is_shared: value.is_shared,
}
@ -270,7 +282,7 @@ impl<T: DataOptions> From<DraftDataFilterDto<T>> for rtsa_db::DraftDataQuery {
Self {
user_id: value.user_id,
name: value.name,
data_type: value.data_type.map(|dt| dt as i32),
data_type: value.data_type,
is_shared: Some(true),
options: value.options.map(|o| serde_json::to_value(o).unwrap()),
}
@ -322,7 +334,7 @@ impl From<rtsa_db::model::DraftDataModel> for DraftDataDto {
Self {
id: value.id,
name: value.name,
data_type: DataType::try_from(value.data_type).unwrap(),
data_type: value.data_type,
options: value.options,
data: value
.data

11
manager/src/apis/feature.rs → manager/crates/rtsa_api/src/apis/feature.rs
View File

@ -1,7 +1,7 @@
use crate::{
apis::{PageDto, PageQueryDto},
loader::RtsaDbLoader,
user_auth::{Jwt, RoleGuard},
user_auth::{RoleGuard, Token, UserAuthCache},
};
use async_graphql::{
dataloader::DataLoader, ComplexObject, Context, InputObject, Object, SimpleObject,
@ -84,8 +84,11 @@ impl FeatureMutation {
mut input: CreateFeatureDto<UrFeatureConfig>,
) -> async_graphql::Result<FeatureDto> {
let dba = ctx.data::<RtsaDbAccessor>()?;
let claims = ctx.data::<Jwt>()?.decode()?;
input = input.with_feature_type_and_user_id(FeatureType::Ur, claims.uid);
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
input = input.with_feature_type_and_user_id(FeatureType::Ur, user.id_i32());
let feature = dba.create_feature(&input.into()).await?;
Ok(feature.into())
}
@ -211,7 +214,7 @@ impl From<rtsa_db::model::FeatureModel> for FeatureDto {
fn from(value: rtsa_db::model::FeatureModel) -> Self {
Self {
id: value.id,
feature_type: FeatureType::try_from(value.feature_type).unwrap(),
feature_type: value.feature_type,
name: value.name,
description: value.description,
config: value.config,

0
manager/src/apis/feature_config_def.rs → manager/crates/rtsa_api/src/apis/feature_config_def.rs
View File

21
manager/src/apis/mod.rs → manager/crates/rtsa_api/src/apis/mod.rs
View File

@ -1,7 +1,6 @@
use async_graphql::{Enum, InputObject, MergedObject, OutputType, SimpleObject};
use draft_data::{DraftDataMutation, DraftDataQuery};
use feature::{FeatureMutation, FeatureQuery};
use org::{OrgMutation, OrgQuery};
use release_data::{ReleaseDataMutation, ReleaseDataQuery};
mod sys_info;
@ -11,29 +10,15 @@ mod data_options_def;
mod draft_data;
mod feature;
mod feature_config_def;
mod org;
mod org_user;
mod release_data;
mod user;
use org_user::{OrgUserMutation, OrgUserQuery};
pub use user::UserLoginDto;
#[derive(Default, MergedObject)]
pub struct Query(
UserQuery,
OrgQuery,
OrgUserQuery,
DraftDataQuery,
ReleaseDataQuery,
FeatureQuery,
);
pub struct Query(UserQuery, DraftDataQuery, ReleaseDataQuery, FeatureQuery);
#[derive(Default, MergedObject)]
pub struct Mutation(
UserMutation,
OrgMutation,
OrgUserMutation,
DraftDataMutation,
ReleaseDataMutation,
FeatureMutation,
@ -89,8 +74,8 @@ impl<T: OutputType> PageDto<T> {
}
}
impl<T: OutputType, M: Into<T>> From<rtsa_db::common::PageData<M>> for PageDto<T> {
fn from(value: rtsa_db::common::PageData<M>) -> Self {
impl<T: OutputType, M: Into<T>> From<rtsa_db::common::PageResult<M>> for PageDto<T> {
fn from(value: rtsa_db::common::PageResult<M>) -> Self {
Self::new(
value.total,
value.data.into_iter().map(|m| m.into()).collect(),

32
manager/src/apis/release_data.rs → manager/crates/rtsa_api/src/apis/release_data.rs
View File

@ -18,7 +18,7 @@ use super::data_options_def::{DataOptions, IscsDataOptions};
use super::user::UserId;
use super::{PageDto, PageQueryDto};
use crate::user_auth::{Jwt, RoleGuard};
use crate::user_auth::{RoleGuard, Token, UserAuthCache};
#[derive(Default)]
pub struct ReleaseDataQuery;
@ -81,7 +81,7 @@ impl ReleaseDataQuery {
) -> async_graphql::Result<bool> {
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let result = db_accessor
.is_release_data_name_exist(data_type as i32, &name)
.is_release_data_name_exist(data_type, &name)
.await?;
Ok(result)
}
@ -127,10 +127,14 @@ impl ReleaseDataMutation {
name: String,
description: String,
) -> async_graphql::Result<ReleaseDataWithUsedVersionDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let user_id = user.id_i32();
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let result = db_accessor
.release_new_from_draft(draft_id, &name, &description, Some(claims.uid))
.release_new_from_draft(draft_id, &name, &description, Some(user_id))
.await?;
Ok(result.into())
}
@ -143,10 +147,14 @@ impl ReleaseDataMutation {
draft_id: i32,
description: String,
) -> async_graphql::Result<ReleaseDataWithUsedVersionDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let user_id = user.id_i32();
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let result = db_accessor
.release_to_existing(draft_id, &description, Some(claims.uid))
.release_to_existing(draft_id, &description, Some(user_id))
.await?;
Ok(result.into())
}
@ -201,10 +209,14 @@ impl ReleaseDataMutation {
ctx: &Context<'_>,
version_id: i32,
) -> async_graphql::Result<DraftDataDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let user_id = user.id_i32();
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let result = db_accessor
.create_draft_from_release_version(version_id, claims.uid)
.create_draft_from_release_version(version_id, user_id)
.await?;
Ok(result.into())
}
@ -228,7 +240,7 @@ impl<T: DataOptions> From<ReleaseTypedDataFilterDto<T>> for rtsa_db::ReleaseData
Self {
name: value.name,
user_id: value.user_id,
data_type: value.data_type.map(|dt| dt as i32),
data_type: value.data_type,
options: value.options.map(|o| serde_json::to_value(o).unwrap()),
is_published: value.is_published,
}
@ -410,7 +422,7 @@ impl From<ReleaseDataModel> for ReleaseDataDto {
Self {
id: model.id,
name: model.name,
data_type: DataType::try_from(model.data_type).unwrap(),
data_type: model.data_type,
options: model.options,
used_version_id: model.used_version_id,
user_id: model.user_id,

0
manager/src/apis/sys_info.rs → manager/crates/rtsa_api/src/apis/sys_info.rs
View File

149
manager/src/apis/user.rs → manager/crates/rtsa_api/src/apis/user.rs
View File

@ -2,12 +2,12 @@ use std::{collections::HashMap, sync::Arc};
use async_graphql::{dataloader::Loader, Context, InputObject, Object, SimpleObject};
use chrono::NaiveDateTime;
use rtsa_db::{model::UserModel, DbAccessError, RtsaDbAccessor, UserAccessor};
use serde_json::json;
use rtsa_db::{DbAccessError, RtsaDbAccessor, UserAccessor};
use crate::{
loader::RtsaDbLoader,
user_auth::{handle_login, Jwt, RoleGuard},
user_auth::{build_jwt, Claims, RoleGuard, Token, UserAuthCache, UserInfoDto},
UserAuthClient,
};
use rtsa_dto::common::Role;
@ -16,31 +16,29 @@ use super::{PageDto, PageQueryDto};
#[derive(Default)]
pub struct UserQuery;
#[derive(Default)]
pub struct UserMutation;
#[Object]
impl UserQuery {
/// 用户登陆
async fn user_login(
&self,
ctx: &Context<'_>,
info: UserLoginDto,
) -> async_graphql::Result<String> {
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let jwt = handle_login(db_accessor, info).await?;
Ok(jwt.0)
}
/// 获取用户信息
#[graphql(guard = "RoleGuard::new(Role::User)")]
async fn login_user_info(&self, ctx: &Context<'_>) -> async_graphql::Result<UserDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let db_accessor = ctx.data::<RtsaDbAccessor>()?;
let user = db_accessor.query_user(claims.uid).await?;
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
Ok(user.into())
}
/// 获取jwt令牌(mqtt验证)
#[graphql(guard = "RoleGuard::new(Role::User)")]
async fn get_jwt(&self, ctx: &Context<'_>) -> async_graphql::Result<String> {
let user = ctx
.data::<UserAuthCache>()?
.query_user(&ctx.data::<Token>()?.0)
.await?;
let jwt = build_jwt(Claims::new(user.id_i32()))?;
Ok(jwt.0)
}
/// 分页查询用户（系统管理）
#[graphql(guard = "RoleGuard::new(Role::Admin)")]
async fn user_paging(
@ -55,74 +53,33 @@ impl UserQuery {
}
}
#[derive(Default)]
pub struct UserMutation;
#[Object]
impl UserMutation {
/// 用户注册
async fn register_user(
&self,
ctx: &Context<'_>,
register: RegisterUserDto,
) -> async_graphql::Result<UserDto> {
let dba = ctx.data::<RtsaDbAccessor>()?;
let user = dba.register_user(register.into()).await?;
Ok(user.into())
}
/// 更新用户角色
/// 同步用户
#[graphql(guard = "RoleGuard::new(Role::Admin)")]
async fn update_user_roles(
&self,
ctx: &Context<'_>,
user_id: i32,
roles: Vec<Role>,
) -> async_graphql::Result<UserDto> {
async fn sync_user(&self, ctx: &Context<'_>) -> async_graphql::Result<bool> {
let http_client = ctx.data::<UserAuthClient>()?;
let users = http_client.query_all_users(ctx.data::<Token>()?).await?;
let dba = ctx.data::<RtsaDbAccessor>()?;
let user = dba
.update_user_roles(user_id, serde_json::to_value(roles).unwrap())
.await?;
Ok(user.into())
}
}
#[derive(Debug, InputObject)]
pub struct UserLoginDto {
pub username: String,
pub password: String,
/// 组织id，组织用户登陆需要
pub org_id: Option<i32>,
}
#[derive(Debug, InputObject)]
pub struct RegisterUserDto {
/// 用户名, 必填,唯一，用于登陆
pub username: String,
/// 昵称, 必填
pub nickname: String,
pub mobile: Option<String>,
pub email: Option<String>,
pub password: String,
}
impl From<RegisterUserDto> for rtsa_db::RegisterUser {
fn from(value: RegisterUserDto) -> Self {
let mut user = Self::new(&value.username, &value.password)
.with_nickname(&value.nickname)
.with_roles(json!([Role::User]));
if let Some(mobile) = value.mobile {
user = user.with_mobile(&mobile);
}
if let Some(email) = value.email {
user = user.with_email(&email);
}
user
dba.sync_user(
users
.into_iter()
.map(|u| u.into())
.collect::<Vec<rtsa_db::SyncUserInfo>>()
.as_slice(),
)
.await?;
Ok(true)
}
}
#[derive(Debug, InputObject)]
pub struct UserQueryDto {
pub id: Option<i32>,
pub username: Option<String>,
pub nickname: Option<String>,
pub name: Option<String>,
pub email: Option<String>,
pub mobile: Option<String>,
pub roles: Option<Vec<Role>>,
@ -132,8 +89,7 @@ impl From<UserQueryDto> for rtsa_db::UserPageFilter {
fn from(value: UserQueryDto) -> Self {
Self {
id: value.id,
username: value.username,
nickname: value.nickname,
name: value.name,
email: value.email,
mobile: value.mobile,
roles: value.roles.map(|r| serde_json::to_value(r).unwrap()),
@ -144,8 +100,7 @@ impl From<UserQueryDto> for rtsa_db::UserPageFilter {
#[derive(Debug, SimpleObject)]
pub struct UserDto {
pub id: i32,
pub username: String,
pub nickname: String,
pub name: String,
pub mobile: Option<String>,
pub email: Option<String>,
pub roles: Vec<Role>,
@ -153,15 +108,28 @@ pub struct UserDto {
pub updated_at: NaiveDateTime,
}
impl From<UserModel> for UserDto {
fn from(value: UserModel) -> Self {
impl From<UserInfoDto> for UserDto {
fn from(value: UserInfoDto) -> Self {
Self {
id: value.id,
username: value.username.clone(),
nickname: value.nickname.clone(),
id: value.id_i32(),
name: value.name(),
mobile: value.mobile.clone(),
email: value.email.clone(),
roles: serde_json::from_value(value.roles).unwrap(),
roles: value.roles(),
created_at: value.created_at().naive_local(),
updated_at: value.updated_at().naive_local(),
}
}
}
impl From<rtsa_db::model::UserModel> for UserDto {
fn from(value: rtsa_db::model::UserModel) -> Self {
Self {
id: value.id,
name: value.username,
mobile: value.mobile,
email: value.email,
roles: value.roles.0,
created_at: value.created_at.naive_local(),
updated_at: value.updated_at.naive_local(),
}
@ -185,10 +153,7 @@ impl Loader<UserId> for RtsaDbLoader {
async fn load(&self, keys: &[UserId]) -> Result<HashMap<UserId, Self::Value>, Self::Error> {
let ids: Vec<i32> = keys.iter().map(|k| k.id).collect();
let rows = self
.db_accessor
.query_user_nicknames(ids.as_slice())
.await?;
let rows = self.db_accessor.query_user_name(ids.as_slice()).await?;
let map: HashMap<UserId, String> = rows
.into_iter()
.map(|row| (UserId::new(row.0), row.1))

7
manager/crates/rtsa_api/src/lib.rs Normal file
View File

@ -0,0 +1,7 @@
// mod jwt_auth;
mod apis;
mod loader;
mod server;
mod user_auth;
pub use server::*;

0
manager/src/loader/mod.rs → manager/crates/rtsa_api/src/loader/mod.rs
View File

39
manager/src/server.rs → manager/crates/rtsa_api/src/server.rs
View File

@ -19,10 +19,13 @@ use crate::apis::{Mutation, Query};
use crate::loader::RtsaDbLoader;
use crate::user_auth;
pub use crate::user_auth::UserAuthClient;
#[derive(Clone)]
pub struct ServerConfig {
pub database_url: String,
pub port: u16,
pub user_auth_client: Option<user_auth::UserAuthClient>,
}
impl ServerConfig {
@ -30,17 +33,27 @@ impl ServerConfig {
Self {
database_url: database_url.to_string(),
port,
user_auth_client: None,
}
}
pub fn with_user_auth_client(mut self, user_auth_client: user_auth::UserAuthClient) -> Self {
self.user_auth_client = Some(user_auth_client);
self
}
pub fn to_socket_addr(&self) -> String {
format!("0.0.0.0:{}", self.port)
}
}
pub async fn serve(config: ServerConfig) -> anyhow::Result<()> {
let client = config
.user_auth_client
.clone()
.expect("user auth client not configured");
let dba = rtsa_db::get_db_accessor(&config.database_url).await;
let schema = new_schema(SchemaOptions::new(dba));
let schema = new_schema(SchemaOptions::new(client, dba));
let app = Router::new()
.route("/", get(graphiql).post(graphql_handler))
@ -82,18 +95,27 @@ async fn graphiql() -> impl IntoResponse {
pub type RtsaAppSchema = Schema<Query, Mutation, EmptySubscription>;
pub struct SchemaOptions {
pub user_auth_client: UserAuthClient,
pub user_info_cache: user_auth::UserAuthCache,
pub rtsa_dba: RtsaDbAccessor,
}
impl SchemaOptions {
pub fn new(rtsa_dba: RtsaDbAccessor) -> Self {
Self { rtsa_dba }
pub fn new(user_auth_client: UserAuthClient, rtsa_dba: RtsaDbAccessor) -> Self {
let user_info_cache = user_auth::UserAuthCache::new(user_auth_client.clone());
Self {
user_auth_client,
user_info_cache,
rtsa_dba,
}
}
}
pub fn new_schema(options: SchemaOptions) -> RtsaAppSchema {
let loader = RtsaDbLoader::new(options.rtsa_dba.clone());
Schema::build(Query::default(), Mutation::default(), EmptySubscription)
.data(options.user_auth_client)
.data(options.user_info_cache)
.data(options.rtsa_dba)
.data(DataLoader::new(loader, tokio::spawn))
// .data(MutexSimulationManager::default())
@ -109,6 +131,15 @@ mod tests {
let dba =
rtsa_db::get_db_accessor("postgresql://joylink:Joylink@0503@localhost:5432/joylink")
.await;
let _ = new_schema(SchemaOptions::new(dba));
let _ = new_schema(SchemaOptions::new(
crate::UserAuthClient {
base_url: "".to_string(),
login_url: "".to_string(),
logout_url: "".to_string(),
user_info_url: "".to_string(),
sync_user_url: "".to_string(),
},
dba,
));
}
}

61
manager/src/user_auth/jwt_auth.rs → manager/crates/rtsa_api/src/user_auth/jwt_auth.rs
View File

@ -1,11 +1,9 @@
use std::sync::LazyLock;
use axum::http::HeaderMap;
use async_graphql::Result;
use jsonwebtoken::{decode, DecodingKey, EncodingKey, Validation};
use serde::{Deserialize, Serialize};
use crate::error::BusinessError;
static KEYS: LazyLock<Keys> = LazyLock::new(|| {
// let secret = std::env::var("JWT_SECRET").expect("JWT_SECRET must be set");
let secret = "joylink".to_string();
@ -26,34 +24,12 @@ impl Keys {
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[derive(Debug)]
pub struct Jwt(pub String);
impl Jwt {
pub fn build_from(claims: Claims) -> Result<Self, BusinessError> {
let token =
jsonwebtoken::encode(&jsonwebtoken::Header::default(), &claims, &KEYS.encoding)?;
Ok(Self(token))
}
pub fn decode(&self) -> Result<Claims, BusinessError> {
let data = decode::<Claims>(&self.0, &KEYS.decoding, &Validation::default())?;
Ok(data.claims)
}
}
pub fn get_token_from_headers(headers: &HeaderMap) -> Option<Jwt> {
headers
.get("Token")
.and_then(|token| token.to_str().map(|s| Jwt(s.to_string())).ok())
}
#[derive(Debug, Serialize, Deserialize)]
pub struct Claims {
/// 用户ID
pub uid: i32,
/// 组织ID
pub oid: i32,
pub id: i32,
exp: usize, // 过期时间，单位秒
}
@ -65,18 +41,28 @@ pub fn get_current_timestamp() -> u64 {
.as_secs()
}
const EXP_TIME: usize = 3600 * 24 * 5; // 5天
impl Claims {
pub fn new(uid: i32, oid: i32) -> Self {
pub fn new(id: i32) -> Self {
Self {
uid,
oid,
exp: get_current_timestamp() as usize + EXP_TIME,
id,
exp: get_current_timestamp() as usize + 3600 * 24 * 7, // 7天
}
}
}
/// 构建jwt
pub fn build_jwt(claims: Claims) -> Result<Jwt> {
let token = jsonwebtoken::encode(&jsonwebtoken::Header::default(), &claims, &KEYS.encoding)?;
Ok(Jwt(token))
}
/// 解析jwt
#[allow(dead_code)]
pub fn decode_jwt(token: &str) -> Result<Claims> {
let data = decode::<Claims>(token, &KEYS.decoding, &Validation::default())?;
Ok(data.claims)
}
#[cfg(test)]
mod tests {
@ -85,14 +71,13 @@ mod tests {
#[test]
fn test_jwt() {
rtsa_log::Logging::default().init();
let claim = Claims::new(5, 1);
let jwt = Jwt::build_from(claim).unwrap();
let claim = Claims::new(5);
let jwt = build_jwt(claim).unwrap();
println!("jwt: {}", jwt.0);
let result = jwt.decode();
let result = decode_jwt(&jwt.0);
match result {
Ok(claims) => {
assert_eq!(claims.uid, 5);
assert_eq!(claims.oid, 1);
assert_eq!(claims.id, 5);
}
Err(e) => {
panic!("Error: {:?}", e);

323
manager/crates/rtsa_api/src/user_auth/mod.rs Normal file
View File

@ -0,0 +1,323 @@
use std::{
collections::{HashMap, HashSet},
sync::{Arc, Mutex},
};
use async_graphql::Guard;
use axum::http::HeaderMap;
use chrono::{DateTime, Local};
use rtsa_dto::common::Role;
use rtsa_log::tracing::error;
use serde::{Deserialize, Serialize};
mod jwt_auth;
pub use jwt_auth::*;
pub struct RoleGuard {
role: Role,
}
impl RoleGuard {
pub fn new(role: Role) -> Self {
Self { role }
}
}
impl Guard for RoleGuard {
async fn check(&self, ctx: &async_graphql::Context<'_>) -> async_graphql::Result<()> {
if let Some(token) = ctx.data_opt::<Token>() {
// 从ctx中获取UserAuthCache, 从cache中获取用户信息
let user_auth_cache = ctx.data::<UserAuthCache>().unwrap();
let user_info = user_auth_cache.query_user(&token.0).await?;
// 判断用户角色
if user_info.roles().contains(&Role::Admin) {
return Ok(());
}
if user_info.roles().contains(&self.role) {
return Ok(());
}
}
Err(async_graphql::Error::new("Unauthorized"))
}
}
pub struct UserAuthCache {
// TODO: 使用 LRU 等缓存策略，而不是简单的 HashMap
cache: Arc<Mutex<HashMap<String, UserInfoDto>>>,
client: UserAuthClient,
}
impl UserAuthCache {
pub fn new(user_auth_client: UserAuthClient) -> Self {
Self {
cache: Arc::new(Mutex::new(HashMap::with_capacity(100))),
client: user_auth_client,
}
}
}
pub struct Token(pub String);
pub fn get_token_from_headers(headers: &HeaderMap) -> Option<Token> {
headers
.get("Token")
.and_then(|token| token.to_str().map(|s| Token(s.to_string())).ok())
}
#[derive(Debug, Clone)]
pub struct UserAuthClient {
pub base_url: String,
pub login_url: String,
pub logout_url: String,
pub user_info_url: String,
pub sync_user_url: String,
}
impl UserAuthClient {
#[allow(dead_code)]
async fn login(&self, login_info: LoginInfo) -> anyhow::Result<String> {
let url = format!("{}{}", self.base_url, self.login_url);
let response = reqwest::Client::new()
.post(&url)
.json(&login_info)
.send()
.await?;
let common = response.json::<CommonResponseDto>().await?;
if common.code != 200 {
// 记录详细日志
error!("Login failed with code {}: {}", common.code, common.message);
return Err(anyhow::anyhow!(common.message));
}
// 安全地处理 Option 类型
match common.data {
Some(data) => {
if let Some(token_str) = data.as_str() {
Ok(token_str.to_string())
} else {
// 记录详细日志
error!("Data is not a string");
Err(anyhow::anyhow!("Data is not a string"))
}
}
None => {
// 记录详细日志
error!("No data returned");
Err(anyhow::anyhow!("No data returned"))
}
}
}
async fn query_user_info(&self, token: &str) -> anyhow::Result<UserInfoDto> {
let url = format!("{}{}?token={token}", self.base_url, self.user_info_url);
let response = reqwest::get(url).await?;
let common = response.json::<CommonResponseDto>().await?;
if common.code != 200 {
return Err(anyhow::anyhow!(common.message));
}
let user_info = serde_json::from_value(common.data.unwrap())?;
Ok(user_info)
}
pub async fn query_all_users(&self, token: &Token) -> anyhow::Result<Vec<UserInfoDto>> {
let url = format!("{}{}", self.base_url, self.sync_user_url);
let response = reqwest::Client::new()
.get(&url)
.header("X-Token", &token.0)
.send()
.await?;
let common = response.json::<CommonResponseDto>().await?;
if common.code != 200 {
return Err(anyhow::anyhow!(common.message));
}
let user_info_list = serde_json::from_value(common.data.unwrap())?;
Ok(user_info_list)
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct LoginInfo {
pub account: String,
pub password: String,
#[serde(rename = "clientId")]
pub client_id: String,
pub secret: String,
pub project: String,
}
impl Default for LoginInfo {
fn default() -> Self {
Self {
account: "17791995809".to_string(),
password: "e10adc3949ba59abbe56e057f20f883e".to_string(),
client_id: "1".to_string(),
secret: "joylink".to_string(),
project: "DEFAULT".to_string(),
}
}
}
#[derive(Debug, Serialize, Deserialize)]
pub struct CommonResponseDto {
pub code: i32,
pub message: String,
pub data: Option<serde_json::Value>,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct UserInfoDto {
pub id: String,
pub name: Option<String>,
pub nickname: Option<String>,
pub roles: Vec<String>,
pub mobile: Option<String>,
pub email: Option<String>,
#[serde(rename = "createTime")]
pub create_time: String,
#[serde(rename = "updateTime")]
pub update_time: Option<String>,
}
impl UserInfoDto {
pub fn id_i32(&self) -> i32 {
self.id
.parse::<i32>()
.expect("parse UserInfoDto.id to i32 failed")
}
pub fn name(&self) -> String {
self.name
.clone()
.or(self.nickname.clone())
.unwrap_or_default()
}
pub fn roles(&self) -> Vec<Role> {
let mut unique_roles = HashSet::new();
for role in &self.roles {
match role.as_str() {
"04" | "05" => {
unique_roles.insert(Role::Admin);
}
"01" | "03" => {
unique_roles.insert(Role::User);
}
_ => {}
}
}
unique_roles.into_iter().collect()
}
pub fn created_at(&self) -> DateTime<Local> {
parse_to_date_time(&self.create_time)
}
pub fn updated_at(&self) -> DateTime<Local> {
parse_to_date_time(self.update_time.as_deref().unwrap_or(&self.create_time))
}
}
fn parse_to_date_time(s: &str) -> chrono::DateTime<Local> {
chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S")
.expect("parse date_time failed")
.and_local_timezone(Local)
.unwrap()
}
impl From<UserInfoDto> for rtsa_db::SyncUserInfo {
fn from(user_info: UserInfoDto) -> Self {
Self {
id: user_info.id_i32(),
name: user_info.name().replace("'", ""), // 需要处理name中带“'”字符的情况
password: "".to_string(), // 暂时先不同步
email: user_info.email.clone(),
mobile: user_info.mobile.clone(),
roles: serde_json::to_value(user_info.roles()).unwrap(),
created_at: parse_to_date_time(&user_info.create_time),
updated_at: user_info.update_time.map(|s| parse_to_date_time(&s)),
}
}
}
impl UserAuthCache {
#[allow(dead_code)]
pub fn len(&self) -> usize {
let cache = self.cache.lock().unwrap();
cache.len()
}
#[allow(dead_code)]
pub fn get_all(&self) -> HashMap<String, UserInfoDto> {
let cache = self.cache.lock().unwrap();
cache.clone()
}
fn insert(&self, key: String, value: UserInfoDto) {
let mut cache = self.cache.lock().unwrap();
cache.insert(key, value);
}
fn get(&self, key: &str) -> Option<UserInfoDto> {
let cache = self.cache.lock().unwrap();
cache.get(key).cloned()
}
pub async fn query_user(&self, token: &str) -> anyhow::Result<UserInfoDto> {
if let Some(user_info) = self.get(token) {
Ok(user_info)
} else {
let user_info = self.client.query_user_info(token).await?;
self.insert(token.to_string(), user_info.clone());
Ok(user_info)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_login_info_serialize() {
let login_info = LoginInfo::default();
let json = serde_json::to_string(&login_info).unwrap();
println!("{}", json);
assert_eq!(
json,
r#"{"account":"17791995809","password":"e10adc3949ba59abbe56e057f20f883e","clientId":"1","secret":"joylink","project":"DEFAULT"}"#
);
let login_info: LoginInfo = serde_json::from_str(&json).unwrap();
assert_eq!(login_info.account, "17791995809");
}
#[test]
fn test_chrono_datetime_parse() {
let time_str = "2021-08-31 10:00:00";
let dt = parse_to_date_time(time_str);
println!("{:?}", dt);
}
// #[tokio::test]
// async fn test_user_auth_cache() -> anyhow::Result<()> {
// rtsa_log::Logging::default().with_level(Level::DEBUG).init();
// let client = UserAuthClient {
// base_url: "http://192.168.33.233/rtsa-server".to_string(),
// login_url: "/api/login".to_string(),
// logout_url: "/api/login/logout".to_string(),
// user_info_url: "/api/login/getUserInfo".to_string(),
// sync_user_url: "/api/userinfo/list/all".to_string(),
// };
// let cache = UserAuthCache::new(client.clone());
// let token = cache.client.login(LoginInfo::default()).await?;
// let user = cache.query_user(&token).await?;
// println!("token: {}, {:?}", token, user);
// assert_eq!(cache.len(), 1);
// let user_list = client.query_all_users(&Token(token)).await?;
// println!("{:?}", user_list);
// Ok(())
// }
}

119
manager/src/apis/org.rs
View File

@ -1,119 +0,0 @@
use std::collections::HashMap;
use std::sync::Arc;
use async_graphql::dataloader::Loader;
use async_graphql::{Context, InputObject, Object, SimpleObject};
use chrono::NaiveDateTime;
use rtsa_db::prelude::*;
use rtsa_dto::common::Role;
use crate::sys_init::DEFAULT_ORG_CODE;
use crate::{
loader::RtsaDbLoader,
user_auth::{Jwt, RoleGuard},
};
#[derive(Default)]
pub struct OrgQuery;
#[derive(Default)]
pub struct OrgMutation;
#[Object]
impl OrgQuery {
/// 获取组织信息
async fn get_org(&self, ctx: &Context<'_>, id: i32) -> async_graphql::Result<OrgDto> {
let dba = ctx.data::<RtsaDbAccessor>()?;
let org = dba.query_org(id).await?;
Ok(org.into())
}
/// 获取默认组织信息
async fn get_default_org(&self, ctx: &Context<'_>) -> async_graphql::Result<OrgDto> {
let dba = ctx.data::<RtsaDbAccessor>()?;
let org = dba.query_org_by_code(DEFAULT_ORG_CODE).await?;
Ok(org.into())
}
}
#[Object]
impl OrgMutation {
/// 创建顶级组织
#[graphql(guard = "RoleGuard::new(Role::Admin)")]
async fn create_top_org(
&self,
ctx: &Context<'_>,
mut c: CreateTopOrgDto,
) -> async_graphql::Result<OrgDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
let dba = ctx.data::<RtsaDbAccessor>()?;
c.creator_id = Some(claims.uid);
let org = dba.create_org(c.into()).await?;
Ok(org.into())
}
}
#[derive(Debug, InputObject)]
pub struct CreateTopOrgDto {
pub code: String,
pub name: String,
#[graphql(skip)]
pub creator_id: Option<i32>,
}
impl From<CreateTopOrgDto> for CreateOrg {
fn from(c: CreateTopOrgDto) -> Self {
Self::new(&c.name, c.creator_id.unwrap()).with_code(&c.code)
}
}
#[derive(Debug, SimpleObject)]
pub struct OrgDto {
pub id: i32,
pub code: Option<String>,
pub name: String,
pub creator_id: i32,
pub created_at: NaiveDateTime,
pub updater_id: i32,
pub updated_at: NaiveDateTime,
}
impl From<OrganizationModel> for OrgDto {
fn from(org: OrganizationModel) -> Self {
Self {
id: org.id,
code: org.code,
name: org.name,
creator_id: org.creator_id,
created_at: org.created_at.naive_local(),
updater_id: org.updater_id,
updated_at: org.updated_at.naive_local(),
}
}
}
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
pub struct OrgId {
pub id: i32,
}
impl OrgId {
pub fn new(id: i32) -> Self {
Self { id }
}
}
impl Loader<OrgId> for RtsaDbLoader {
type Value = String;
type Error = Arc<DbAccessError>;
async fn load(&self, keys: &[OrgId]) -> Result<HashMap<OrgId, Self::Value>, Self::Error> {
let ids: Vec<i32> = keys.iter().map(|k| k.id).collect();
let rows = self.db_accessor.query_org_names(ids.as_slice()).await?;
let map: HashMap<OrgId, String> = rows
.into_iter()
.map(|row| (OrgId::new(row.0), row.1))
.collect();
Ok(map)
}
}

145
manager/src/apis/org_user.rs
View File

@ -1,145 +0,0 @@
use crate::{
loader::RtsaDbLoader,
user_auth::{Jwt, RoleGuard},
};
use async_graphql::{
dataloader::DataLoader, ComplexObject, Context, InputObject, Object, SimpleObject,
};
use chrono::NaiveDateTime;
use rtsa_db::prelude::*;
use rtsa_dto::common::Role;
use super::{org::OrgId, user::UserId};
#[derive(Default)]
pub struct OrgUserQuery;
#[derive(Default)]
pub struct OrgUserMutation;
#[Object]
impl OrgUserQuery {
/// 获取组织用户信息
#[graphql(guard = "RoleGuard::new(Role::User)")]
async fn org_user_info(
&self,
ctx: &Context<'_>,
org_id: i32,
user_id: i32,
) -> async_graphql::Result<OrgUserDto> {
let org_user = ctx
.data::<RtsaDbAccessor>()?
.query_org_user(org_id, user_id)
.await?;
Ok(org_user.into())
}
}
#[Object]
impl OrgUserMutation {
/// 绑定组织用户(用于组织和用户都已经存在的情况)
#[graphql(
guard = "RoleGuard::new(Role::Admin).or(RoleGuard::new(Role::OrgManager)).or(RoleGuard::new(Role::OrgTeacher))"
)]
async fn bind_org_user(
&self,
ctx: &Context<'_>,
mut bind: BindOrgUserDto,
) -> async_graphql::Result<OrgUserDto> {
let claims = ctx.data::<Jwt>()?.decode()?;
bind.creator_id = Some(claims.uid);
let org_user = ctx
.data::<RtsaDbAccessor>()?
.bind_org_user(bind.into())
.await?;
Ok(org_user.into())
}
/// 删除组织用户
#[graphql(guard = "RoleGuard::new(Role::Admin)")]
async fn delete_org_user(&self, ctx: &Context<'_>, id: i32) -> async_graphql::Result<bool> {
ctx.data::<RtsaDbAccessor>()?.delete_org_user(id).await?;
Ok(true)
}
}
/// 绑定组织用户输入对象
#[derive(InputObject)]
pub struct BindOrgUserDto {
pub org_id: i32,
pub user_id: i32,
pub student_id: Option<String>,
pub roles: Vec<Role>,
#[graphql(skip)]
pub creator_id: Option<i32>,
}
impl From<BindOrgUserDto> for BindOrgUser {
fn from(value: BindOrgUserDto) -> Self {
let mut obj = Self::new(value.org_id, value.user_id, value.creator_id.unwrap())
.with_roles(serde_json::to_value(value.roles).unwrap());
if let Some(student_id) = value.student_id {
obj = obj.with_student_id(&student_id);
}
obj
}
}
#[derive(Debug, SimpleObject)]
pub struct OrgUserDto {
pub id: i32,
pub org_id: i32,
pub user_id: i32,
pub student_id: Option<String>,
pub roles: Vec<Role>,
pub creator_id: i32,
pub created_at: NaiveDateTime,
pub updater_id: i32,
pub updated_at: NaiveDateTime,
}
#[ComplexObject]
impl OrgUserDto {
/// 获取组织name
async fn org_name(&self, ctx: &Context<'_>) -> async_graphql::Result<Option<String>> {
let loader = ctx.data_unchecked::<DataLoader<RtsaDbLoader>>();
let name = loader.load_one(OrgId::new(self.org_id)).await?;
Ok(name)
}
/// 获取用户name
async fn user_name(&self, ctx: &Context<'_>) -> async_graphql::Result<Option<String>> {
let loader = ctx.data_unchecked::<DataLoader<RtsaDbLoader>>();
let name = loader.load_one(UserId::new(self.user_id)).await?;
Ok(name)
}
/// 获取创建者name
async fn creator_name(&self, ctx: &Context<'_>) -> async_graphql::Result<Option<String>> {
let loader = ctx.data_unchecked::<DataLoader<RtsaDbLoader>>();
let name = loader.load_one(UserId::new(self.creator_id)).await?;
Ok(name)
}
/// 获取更新者name
async fn updater_name(&self, ctx: &Context<'_>) -> async_graphql::Result<Option<String>> {
let loader = ctx.data_unchecked::<DataLoader<RtsaDbLoader>>();
let name = loader.load_one(UserId::new(self.updater_id)).await?;
Ok(name)
}
}
impl From<OrganizationUserModel> for OrgUserDto {
fn from(value: OrganizationUserModel) -> Self {
Self {
id: value.id,
org_id: value.organization_id,
user_id: value.user_id,
student_id: value.student_id.clone(),
roles: serde_json::from_value(value.roles).unwrap(),
creator_id: value.creator_id,
created_at: value.created_at.naive_local(),
updater_id: value.updater_id,
updated_at: value.updated_at.naive_local(),
}
}
}

11
manager/src/app_config.rs
View File

@ -29,12 +29,23 @@ impl From<Log> for rtsa_log::Logging {
}
}
#[derive(Debug, Deserialize)]
#[allow(unused)]
pub struct Sso {
pub base_url: String,
pub login_url: String,
pub logout_url: String,
pub user_info_url: String,
pub sync_user_url: String,
}
#[derive(Debug, Deserialize)]
#[allow(unused)]
pub struct AppConfig {
pub server: Server,
pub log: Log,
pub database: Database,
pub sso: Sso,
}
impl AppConfig {

16
manager/src/commands/cmd.rs
View File

@ -1,7 +1,7 @@
use clap::Parser;
use enum_dispatch::enum_dispatch;
use crate::{app_config, server, CmdExecutor};
use crate::{app_config, CmdExecutor};
use super::DbSubCommand;
@ -33,10 +33,16 @@ impl CmdExecutor for ServerOpts {
app_config::AppConfig::new(&self.config_path).expect("Failed to load app config");
let log: rtsa_log::Logging = app_config.log.into();
log.init();
server::serve(server::ServerConfig::new(
&app_config.database.url,
app_config.server.port,
))
rtsa_api::serve(
rtsa_api::ServerConfig::new(&app_config.database.url, app_config.server.port)
.with_user_auth_client(rtsa_api::UserAuthClient {
base_url: app_config.sso.base_url,
login_url: app_config.sso.login_url,
logout_url: app_config.sso.logout_url,
user_info_url: app_config.sso.user_info_url,
sync_user_url: app_config.sso.sync_user_url,
}),
)
.await
}
}

8
manager/src/commands/db.rs
View File

@ -1,7 +1,7 @@
use clap::Parser;
use enum_dispatch::enum_dispatch;
use crate::{app_config, sys_init::init_default_user_and_org, CmdExecutor};
use crate::{app_config, CmdExecutor};
#[derive(Parser, Debug)]
#[enum_dispatch(CmdExecutor)]
@ -22,10 +22,6 @@ impl CmdExecutor for MigrateOpts {
async fn execute(&self) -> anyhow::Result<()> {
let app_config =
app_config::AppConfig::new(&self.config_path).expect("Failed to load app config");
let log: rtsa_log::Logging = app_config.log.into();
log.init();
rtsa_db::run_migrations(&app_config.database.url).await?;
rtsa_db::init_default_db_accessor(&app_config.database.url).await;
init_default_user_and_org().await
rtsa_db::run_migrations(&app_config.database.url).await
}
}

18
manager/src/error.rs
View File

@ -1,18 +0,0 @@
use thiserror::Error;
#[allow(dead_code)]
#[derive(Error, Debug)]
pub enum BusinessError {
#[error("未知错误: {0}")]
Unknown(String),
#[error("{0}")]
DbError(#[from] rtsa_db::DbAccessError),
#[error(transparent)]
Other(#[from] anyhow::Error),
#[error("非法参数：{0}")]
InvalidArgument(String),
#[error("认证失败：{0}")]
AuthError(String),
#[error("JWT错误：{0}")]
JwtError(#[from] jsonwebtoken::errors::Error),
}

9
manager/src/lib.rs
View File

@ -1,13 +1,4 @@
mod app_config;
mod commands;
mod sys_init;
// mod jwt_auth;
mod apis;
mod error;
mod loader;
mod server;
mod user_auth;
pub use server::*;
pub use commands::*;

78
manager/src/sys_init/mod.rs
View File

@ -1,78 +0,0 @@
//! 系统初始化
use rtsa_db::{OrgAccessor, UserAccessor};
use rtsa_dto::common::Role;
use rtsa_log::tracing::{debug, error, info};
use serde_json::json;
pub const ADMIN_USER_NAME: &str = "_jl_admin_";
pub const ADMIN_USER_PASSWORD: &str = "joylink0503";
pub const DEFAULT_ORG_CODE: &str = "default";
const DEFAULT_ORG_NAME: &str = "默认机构";
/// 初始化默认用户及组织
/// 注意：需要在初始化默认数据库后调用，初始化默认数据库方法： [rtsa_db::init_default_db_accessor] or [rtsa_db::set_default_db_accessor]
pub(crate) async fn init_default_user_and_org() -> anyhow::Result<()> {
let admin_user = rtsa_db::RegisterUser::new(ADMIN_USER_NAME, ADMIN_USER_PASSWORD)
.with_roles(json!([Role::Admin]));
let db_accessor = rtsa_db::get_default_db_accessor();
let admin = db_accessor.register_user(admin_user).await;
match admin {
Ok(admin) => {
let org =
rtsa_db::CreateOrg::new(DEFAULT_ORG_NAME, admin.id).with_code(DEFAULT_ORG_CODE);
db_accessor.create_org(org).await?;
info!(
"初始化默认用户及组织成功. 用户: {}, 密码: {}, 组织: {}",
ADMIN_USER_NAME, ADMIN_USER_PASSWORD, DEFAULT_ORG_NAME
);
Ok(())
}
Err(e) => {
if db_accessor.is_user_name_exist(ADMIN_USER_NAME).await?
&& db_accessor.is_org_code_exist(DEFAULT_ORG_CODE).await?
{
debug!("默认用户及组织已存在");
} else {
error!("初始化默认用户失败: {:?}", e);
}
Ok(())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use rtsa_db::RtsaDbAccessor;
use rtsa_log::{tracing::Level, Logging};
use sqlx::PgPool;
#[sqlx::test(migrator = "rtsa_db::MIGRATOR")]
async fn test_init_default_user_and_org(pool: PgPool) -> anyhow::Result<()> {
Logging::default().with_level(Level::DEBUG).init();
let accessor = RtsaDbAccessor::new(pool);
rtsa_db::set_default_db_accessor(accessor);
init_default_user_and_org().await.unwrap();
// 重复初始化
init_default_user_and_org().await?;
// 验证用户及组织是否存在
let db_accessor = rtsa_db::get_default_db_accessor();
let user = db_accessor.query_user_by_username(ADMIN_USER_NAME).await?;
assert_eq!(user.username, ADMIN_USER_NAME);
assert_eq!(user.password, ADMIN_USER_PASSWORD);
assert_eq!(user.nickname, ADMIN_USER_NAME);
assert_eq!(user.roles, json!([Role::Admin]));
let org = db_accessor.query_org_by_code(DEFAULT_ORG_CODE).await?;
assert_eq!(org.code.unwrap(), DEFAULT_ORG_CODE);
assert_eq!(org.name, DEFAULT_ORG_NAME);
assert_eq!(org.creator_id, user.id);
Ok(())
}
}

135
manager/src/user_auth/mod.rs
View File

@ -1,135 +0,0 @@
use async_graphql::Guard;
use rtsa_db::prelude::*;
use rtsa_dto::common::Role;
use rtsa_log::tracing::warn;
mod jwt_auth;
use crate::{apis::UserLoginDto, error::BusinessError, sys_init::DEFAULT_ORG_CODE};
pub use jwt_auth::*;
pub struct RoleGuard {
role: Role,
}
impl RoleGuard {
pub fn new(role: Role) -> Self {
Self { role }
}
}
impl Guard for RoleGuard {
async fn check(&self, ctx: &async_graphql::Context<'_>) -> async_graphql::Result<()> {
if let Some(jwt) = ctx.data_opt::<Jwt>() {
// 从ctx中获取UserAuthCache, 从cache中获取用户信息
let claims = jwt.decode()?;
let dba = ctx.data::<RtsaDbAccessor>()?;
let user = dba.query_user(claims.uid).await?;
let user_roles: Vec<Role> = serde_json::from_value(user.roles)?;
// 判断用户角色, 如果是管理员则直接通过
if user_roles.contains(&Role::Admin) {
return Ok(());
}
// 其他用户, 则判断是否有权限
if user_roles.contains(&self.role) {
return Ok(());
}
// 判断组织用户角色
let org_user_roles: Vec<Role>;
let org_user = dba.query_org_user(claims.oid, claims.uid).await;
if let Ok(org_user) = org_user {
org_user_roles = serde_json::from_value(org_user.roles)?;
} else {
// 组织用户不存在，构造组织游客角色用户
org_user_roles = vec![Role::OrgGuest];
}
if org_user_roles.contains(&self.role) {
return Ok(());
}
}
Err(async_graphql::Error::new("Unauthorized"))
}
}
/// 处理用户登录
pub(crate) async fn handle_login(
db_accessor: &RtsaDbAccessor,
info: UserLoginDto,
) -> Result<Jwt, BusinessError> {
let org_id;
if let Some(oid) = info.org_id {
org_id = oid;
} else {
let default_org = db_accessor.query_org_by_code(DEFAULT_ORG_CODE).await?;
org_id = default_org.id;
}
// 查询用户登陆
let user = db_accessor
.query_user_login(&info.username, &info.password)
.await;
match user {
Ok(user) => {
// 用户存在
Ok(Jwt::build_from(Claims::new(user.id, org_id))?)
}
Err(_) => {
// 用户不存在，查询组织用户学工号+用户密码
// 通过组织id和学工号查询组织用户
let org_user = db_accessor
.query_org_user_by_student_id(org_id, &info.username)
.await;
if org_user.is_err() {
warn!("用户不存在: username={}, org_id={}", info.username, org_id);
return Err(BusinessError::AuthError(
"用户不存在或密码不正确".to_string(),
));
}
let org_user = org_user.unwrap();
let user = db_accessor.query_user(org_user.user_id).await?;
// 检查用户密码
if rtsa_db::password_util::verify_password(&info.password, &user.password) {
Ok(Jwt::build_from(Claims::new(user.id, org_id))?)
} else {
warn!("密码不匹配: username={}, org_id={}", info.username, org_id);
Err(BusinessError::AuthError(
"用户不存在或密码不正确".to_string(),
))
}
}
}
}
#[cfg(test)]
mod tests {
use crate::sys_init::{init_default_user_and_org, ADMIN_USER_NAME, ADMIN_USER_PASSWORD};
use super::*;
use rtsa_log::{
tracing::{info, Level},
Logging,
};
use rtsa_db::RtsaDbAccessor;
use sqlx::PgPool;
#[sqlx::test(migrator = "rtsa_db::MIGRATOR")]
async fn test_handle_login(pool: PgPool) -> anyhow::Result<()> {
Logging::default().with_level(Level::DEBUG).init();
let accessor = RtsaDbAccessor::new(pool);
rtsa_db::set_default_db_accessor(accessor.clone());
init_default_user_and_org().await.unwrap();
let info = UserLoginDto {
username: ADMIN_USER_NAME.to_string(),
password: ADMIN_USER_PASSWORD.to_string(),
org_id: None,
};
let jwt = handle_login(&accessor, info).await.unwrap();
info!("jwt: {:?}", jwt);
let claims = jwt.decode().unwrap();
let user = accessor.query_user_by_username(ADMIN_USER_NAME).await?;
assert_eq!(claims.uid, user.id);
let org = accessor.query_org_by_code(DEFAULT_ORG_CODE).await?;
assert_eq!(claims.oid, org.id);
Ok(())
}
}

471
migrations/20240830095636_init.up.sql
View File

@ -8,13 +8,11 @@ CREATE SEQUENCE rtsa.mqtt_client_id_seq;
CREATE TABLE
rtsa.user (
id SERIAL PRIMARY KEY, -- id 自增主键
username VARCHAR(128) NOT NULL UNIQUE, -- 用户名
password VARCHAR(256) NOT NULL, -- 密码
nickname VARCHAR(128) NOT NULL DEFAULT 'user', -- 昵称
email VARCHAR(128) NULL UNIQUE, -- 邮箱
mobile VARCHAR(16) NULL UNIQUE, -- 手机号
username VARCHAR(128) NOT NULL, -- 用户名
password VARCHAR(128) NOT NULL, -- 密码
email VARCHAR(128) NULL, -- 邮箱
mobile VARCHAR(16) NULL, -- 手机号
roles JSONB NOT NULL DEFAULT '[]', -- 角色列表
info JSONB NOT NULL DEFAULT '{}', -- 用户信息
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP -- 更新时间
);
@ -22,12 +20,6 @@ CREATE TABLE
-- 创建用户名称索引
CREATE INDEX ON rtsa.user (username);
-- 创建用户密码索引
CREATE INDEX ON rtsa.user (password);
-- 创建用户昵称索引
CREATE INDEX ON rtsa.user (nickname);
-- 创建用户邮箱索引
CREATE INDEX ON rtsa.user (email);
@ -47,290 +39,16 @@ COMMENT ON COLUMN rtsa.user.username IS '用户名';
COMMENT ON COLUMN rtsa.user.password IS '密码';
COMMENT ON COLUMN rtsa.user.nickname IS '昵称';
COMMENT ON COLUMN rtsa.user.email IS '邮箱';
COMMENT ON COLUMN rtsa.user.mobile IS '手机号';
COMMENT ON COLUMN rtsa.user.roles IS '角色列表';
COMMENT ON COLUMN rtsa.user.info IS '用户信息';
COMMENT ON COLUMN rtsa.user.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.user.updated_at IS '更新时间';
-- 创建组织表
CREATE TABLE
rtsa.organization (
id SERIAL PRIMARY KEY, -- id 自增主键
code VARCHAR(128) NULL UNIQUE, -- 组织编码
name VARCHAR(128) NOT NULL, -- 组织名称
config JSONB NULL, -- 配置数据
parent_id INT NULL, -- 父组织id
creator_id INT NOT NULL, -- 创建用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updater_id INT NOT NULL, -- 更新用户id
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (parent_id) REFERENCES rtsa.organization (id) ON DELETE CASCADE, -- 父组织外键
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 创建用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE -- 更新用户外键
);
-- 创建组织编码索引
CREATE INDEX ON rtsa.organization (code);
-- 创建组织名称索引
CREATE INDEX ON rtsa.organization (name);
-- 创建组织父组织索引
CREATE INDEX ON rtsa.organization (parent_id);
-- 创建组织创建用户索引
CREATE INDEX ON rtsa.organization (creator_id);
-- 创建组织更新用户索引
CREATE INDEX ON rtsa.organization (updater_id);
-- 注释组织表
COMMENT ON TABLE rtsa.organization IS '组织表';
-- 注释组织表字段
COMMENT ON COLUMN rtsa.organization.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.organization.code IS '组织编码';
COMMENT ON COLUMN rtsa.organization.name IS '组织名称';
COMMENT ON COLUMN rtsa.organization.config IS '配置数据';
COMMENT ON COLUMN rtsa.organization.parent_id IS '父组织id';
COMMENT ON COLUMN rtsa.organization.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.organization.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.organization.updater_id IS '更新用户id';
COMMENT ON COLUMN rtsa.organization.updated_at IS '更新时间';
-- 创建组织用户表
CREATE TABLE
rtsa.organization_user (
id SERIAL PRIMARY KEY, -- id 自增主键
organization_id INT NOT NULL, -- 组织id
user_id INT NOT NULL, -- 用户id
student_id VARCHAR(32) NULL, -- 学工号
roles JSONB NOT NULL DEFAULT '[]', -- 组织角色列表
info JSONB NULL, -- 组织用户额外信息
creator_id INT NOT NULL, -- 创建用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updater_id INT NOT NULL, -- 更新用户id
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (organization_id) REFERENCES rtsa.organization (id) ON DELETE CASCADE, -- 组织外键
FOREIGN KEY (user_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 用户外键
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 创建用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 更新用户外键
UNIQUE(organization_id, student_id), -- 组织id+学工号唯一
UNIQUE(organization_id, user_id) -- 组织id+用户id唯一
);
-- 创建组织用户组织索引
CREATE INDEX ON rtsa.organization_user (organization_id);
-- 创建组织用户用户索引
CREATE INDEX ON rtsa.organization_user (user_id);
-- 创建组织用户学工号索引
CREATE INDEX ON rtsa.organization_user (student_id);
-- 创建组织用户角色索引
CREATE INDEX ON rtsa.organization_user USING GIN (roles);
-- 创建组织用户创建用户索引
CREATE INDEX ON rtsa.organization_user (creator_id);
-- 创建组织用户更新用户索引
CREATE INDEX ON rtsa.organization_user (updater_id);
-- 注释组织用户表
COMMENT ON TABLE rtsa.organization_user IS '组织用户表';
-- 注释组织用户表字段
COMMENT ON COLUMN rtsa.organization_user.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.organization_user.organization_id IS '组织id';
COMMENT ON COLUMN rtsa.organization_user.user_id IS '用户id';
COMMENT ON COLUMN rtsa.organization_user.student_id IS '学工号';
COMMENT ON COLUMN rtsa.organization_user.roles IS '组织角色列表';
COMMENT ON COLUMN rtsa.organization_user.info IS '组织用户其他信息';
COMMENT ON COLUMN rtsa.organization_user.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.organization_user.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.organization_user.updater_id IS '更新用户id';
COMMENT ON COLUMN rtsa.organization_user.updated_at IS '更新时间';
-- 创建组织数据表
CREATE TABLE
rtsa.organization_data (
id SERIAL PRIMARY KEY, -- id 自增主键
organization_id INT NOT NULL, -- 组织id
data_type INT NOT NULL, -- 数据类型
data JSONB NOT NULL, -- 数据
creator_id INT NOT NULL, -- 创建用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updater_id INT NOT NULL, -- 更新用户id
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (organization_id) REFERENCES rtsa.organization (id) ON DELETE CASCADE, -- 组织外键
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 创建用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE -- 更新用户外键
);
-- 创建组织数据组织索引
CREATE INDEX ON rtsa.organization_data (organization_id);
-- 创建组织数据类型索引
CREATE INDEX ON rtsa.organization_data (data_type);
-- 创建组织数据配置项索引
CREATE INDEX ON rtsa.organization_data USING GIN (data);
-- 创建组织数据创建用户索引
CREATE INDEX ON rtsa.organization_data (creator_id);
-- 创建组织数据更新用户索引
CREATE INDEX ON rtsa.organization_data (updater_id);
-- 创建组织数据索引
CREATE INDEX ON rtsa.organization_data (organization_id, data_type);
-- 注释组织数据表
COMMENT ON TABLE rtsa.organization_data IS '组织数据表';
-- 注释组织数据表字段
COMMENT ON COLUMN rtsa.organization_data.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.organization_data.organization_id IS '组织id';
COMMENT ON COLUMN rtsa.organization_data.data_type IS '数据类型';
COMMENT ON COLUMN rtsa.organization_data.data IS '数据';
COMMENT ON COLUMN rtsa.organization_data.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.organization_data.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.organization_data.updater_id IS '更新用户id';
COMMENT ON COLUMN rtsa.organization_data.updated_at IS '更新时间';
-- 创建feature表
CREATE TABLE
rtsa.feature (
id SERIAL PRIMARY KEY, -- id 自增主键
feature_type INT NOT NULL, -- feature类型
name VARCHAR(128) NOT NULL, -- feature名称
description TEXT NOT NULL, -- feature描述
config JSONB NOT NULL, -- feature配置
is_published BOOLEAN NOT NULL DEFAULT TRUE, -- 是否上架
creator_id INT NOT NULL, -- 创建用户id
updater_id INT NOT NULL, -- 更新用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 用户外键
UNIQUE(feature_type, name) -- feature类型和名称唯一
);
-- 创建feature类型索引
CREATE INDEX ON rtsa.feature (feature_type);
-- 创建feature名称索引
CREATE INDEX ON rtsa.feature (name);
-- 注释仿真feature表
COMMENT ON TABLE rtsa.feature IS 'feature表';
-- 注释仿真feature表字段
COMMENT ON COLUMN rtsa.feature.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.feature.feature_type IS 'feature类型';
COMMENT ON COLUMN rtsa.feature.name IS 'feature名称';
COMMENT ON COLUMN rtsa.feature.description IS 'feature描述';
COMMENT ON COLUMN rtsa.feature.config IS 'feature配置';
COMMENT ON COLUMN rtsa.feature.is_published IS '是否上架';
COMMENT ON COLUMN rtsa.feature.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.feature.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.feature.updated_at IS '更新时间';
-- 创建组织功能表
CREATE TABLE
rtsa.organization_feature (
id SERIAL PRIMARY KEY, -- id 自增主键
organization_id INT NOT NULL, -- 组织id
feature_id INT NOT NULL, -- feature id
config JSONB NOT NULL, -- 组织功能配置
creator_id INT NOT NULL, -- 创建用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updater_id INT NOT NULL, -- 更新用户id
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (organization_id) REFERENCES rtsa.organization (id) ON DELETE CASCADE, -- 组织外键
FOREIGN KEY (feature_id) REFERENCES rtsa.feature (id) ON DELETE CASCADE, -- feature外键
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 创建用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 更新用户外键
UNIQUE(organization_id, feature_id) -- 组织id和feature id唯一
);
-- 创建组织功能组织索引
CREATE INDEX ON rtsa.organization_feature (organization_id);
-- 创建组织功能feature索引
CREATE INDEX ON rtsa.organization_feature (feature_id);
-- 创建组织功能配置项索引
CREATE INDEX ON rtsa.organization_feature USING GIN (config);
-- 创建组织功能创建用户索引
CREATE INDEX ON rtsa.organization_feature (creator_id);
-- 创建组织功能更新用户索引
CREATE INDEX ON rtsa.organization_feature (updater_id);
-- 注释组织功能表
COMMENT ON TABLE rtsa.organization_feature IS '组织功能表';
-- 注释组织功能表字段
COMMENT ON COLUMN rtsa.organization_feature.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.organization_feature.organization_id IS '组织id';
COMMENT ON COLUMN rtsa.organization_feature.feature_id IS 'feature id';
COMMENT ON COLUMN rtsa.organization_feature.config IS '组织功能配置';
COMMENT ON COLUMN rtsa.organization_feature.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.organization_feature.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.organization_feature.updater_id IS '更新用户id';
COMMENT ON COLUMN rtsa.organization_feature.updated_at IS '更新时间';
-- 创建草稿数据表
CREATE TABLE
rtsa.draft_data (
@ -345,7 +63,7 @@ CREATE TABLE
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (user_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 用户外键
UNIQUE(name, data_type, user_id) -- 一个用户的某个类型的草稿名称唯一
UNIQUE (name, data_type, user_id) -- 一个用户的某个类型的草稿名称唯一
);
-- 创建草稿数据用户索引
@ -476,176 +194,81 @@ COMMENT ON COLUMN rtsa.release_data_version.user_id IS '发布用户id';
COMMENT ON COLUMN rtsa.release_data_version.created_at IS '创建时间';
-- 创建发布数据集表
-- 创建feature表
CREATE TABLE
rtsa.release_data_set (
rtsa.feature (
id SERIAL PRIMARY KEY, -- id 自增主键
data_set_type INT NOT NULL, -- 数据集类型
name VARCHAR(128) NOT NULL, -- 发布数据集名称
description TEXT NOT NULL, -- 发布数据集描述
config JSONB NULL, -- 数据集相关配置项
feature_type INT NOT NULL, -- feature类型
name VARCHAR(128) NOT NULL UNIQUE, -- feature名称
description TEXT NOT NULL, -- feature描述
config JSONB NOT NULL, -- feature配置
is_published BOOLEAN NOT NULL DEFAULT TRUE, -- 是否上架
creator_id INT NOT NULL, -- 创建用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updater_id INT NOT NULL, -- 更新用户id
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 创建用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 更新用户外键
UNIQUE(data_set_type, name) -- 数据集类型+name唯一
FOREIGN KEY (creator_id) REFERENCES rtsa.user (id) ON DELETE CASCADE, -- 用户外键
FOREIGN KEY (updater_id) REFERENCES rtsa.user (id) ON DELETE CASCADE -- 用户外键
);
-- 创建发布数据集类型索引
CREATE INDEX ON rtsa.release_data_set (data_set_type);
-- 创建feature类型索引
CREATE INDEX ON rtsa.feature (feature_type);
-- 创建发布数据集名称索引
CREATE INDEX ON rtsa.release_data_set (name);
-- 创建feature名称索引
CREATE INDEX ON rtsa.feature (name);
-- 创建发布数据集配置项索引
CREATE INDEX ON rtsa.release_data_set USING GIN (config);
-- 注释仿真feature表
COMMENT ON TABLE rtsa.feature IS 'feature表';
-- 创建发布数据集创建用户索引
CREATE INDEX ON rtsa.release_data_set (creator_id);
-- 注释仿真feature表字段
COMMENT ON COLUMN rtsa.feature.id IS 'id 自增主键';
-- 创建发布数据集更新用户索引
CREATE INDEX ON rtsa.release_data_set (updater_id);
COMMENT ON COLUMN rtsa.feature.feature_type IS 'feature类型';
-- 创建发布数据集索引
CREATE INDEX ON rtsa.release_data_set (data_set_type, name);
COMMENT ON COLUMN rtsa.feature.name IS 'feature名称';
-- 注释发布数据集表
COMMENT ON TABLE rtsa.release_data_set IS '发布数据集表';
COMMENT ON COLUMN rtsa.feature.description IS 'feature描述';
-- 注释发布数据集表字段
COMMENT ON COLUMN rtsa.release_data_set.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.feature.config IS 'feature配置';
COMMENT ON COLUMN rtsa.release_data_set.data_set_type IS '数据集类型';
COMMENT ON COLUMN rtsa.feature.is_published IS '是否上架';
COMMENT ON COLUMN rtsa.release_data_set.name IS '发布数据集名称';
COMMENT ON COLUMN rtsa.feature.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.release_data_set.description IS '发布数据集描述';
COMMENT ON COLUMN rtsa.feature.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.release_data_set.config IS '数据集相关配置项';
COMMENT ON COLUMN rtsa.feature.updated_at IS '更新时间';
COMMENT ON COLUMN rtsa.release_data_set.is_published IS '是否上架';
COMMENT ON COLUMN rtsa.release_data_set.creator_id IS '创建用户id';
COMMENT ON COLUMN rtsa.release_data_set.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.release_data_set.updater_id IS '更新用户id';
COMMENT ON COLUMN rtsa.release_data_set.updated_at IS '更新时间';
-- 创建发布数据集数据表
-- 创建用户配置表
CREATE TABLE
rtsa.release_data_set_data (
id SERIAL PRIMARY KEY, -- id 自增主键
release_data_set_id INT NOT NULL, -- 发布数据集id
release_data_id INT NOT NULL, -- 发布数据id
order_index INT NOT NULL, -- 排序索引
FOREIGN KEY (release_data_set_id) REFERENCES rtsa.release_data_set (id) ON DELETE CASCADE, -- 发布数据集外键
FOREIGN KEY (release_data_id) REFERENCES rtsa.release_data (id) ON DELETE CASCADE, -- 发布数据外键
UNIQUE(release_data_set_id, release_data_id) -- 发布数据集id和发布数据id唯一
);
-- 创建发布数据集数据发布数据集索引
CREATE INDEX ON rtsa.release_data_set_data (release_data_set_id);
-- 创建发布数据集数据发布数据索引
CREATE INDEX ON rtsa.release_data_set_data (release_data_id);
-- 注释发布数据集数据表
COMMENT ON TABLE rtsa.release_data_set_data IS '发布数据集数据表';
-- 注释发布数据集数据表字段
COMMENT ON COLUMN rtsa.release_data_set_data.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.release_data_set_data.release_data_set_id IS '发布数据集id';
COMMENT ON COLUMN rtsa.release_data_set_data.release_data_id IS '发布数据id';
COMMENT ON COLUMN rtsa.release_data_set_data.order_index IS '排序索引';
-- 创建用户数据表
CREATE TABLE
rtsa.user_data (
rtsa.user_config (
id SERIAL PRIMARY KEY, -- id 自增主键
user_id INT NOT NULL, -- 用户id
data_type INT NOT NULL, -- 数据类型
data JSONB NOT NULL, -- 数据
config_type INT NOT NULL, -- 配置类型
config BYTEA NOT NULL, -- 配置
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 更新时间
FOREIGN KEY (user_id) REFERENCES rtsa.user (id) ON DELETE CASCADE -- 用户外键
);
-- 创建用户数据用户索引
CREATE INDEX ON rtsa.user_data (user_id);
-- 创建用户配置用户索引
CREATE INDEX ON rtsa.user_config (user_id);
-- 创建用户数据类型索引
CREATE INDEX ON rtsa.user_data (data_type);
-- 创建用户配置类型索引
CREATE INDEX ON rtsa.user_config (config_type);
-- 创建用户数据配置项索引
CREATE INDEX ON rtsa.user_data USING GIN (data);
-- 注释用户feature配置表
COMMENT ON TABLE rtsa.user_config IS '用户feature配置表';
-- 创建用户数据索引
CREATE INDEX ON rtsa.user_data (user_id, data_type);
-- 注释用户feature配置表字段
COMMENT ON COLUMN rtsa.user_config.id IS 'id 自增主键';
-- 注释用户数据表
COMMENT ON TABLE rtsa.user_data IS '用户数据表';
COMMENT ON COLUMN rtsa.user_config.user_id IS '用户id';
-- 注释用户数据表字段
COMMENT ON COLUMN rtsa.user_data.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.user_config.config_type IS '配置类型';
COMMENT ON COLUMN rtsa.user_data.user_id IS '用户id';
COMMENT ON COLUMN rtsa.user_config.config IS '配置';
COMMENT ON COLUMN rtsa.user_data.data_type IS '数据类型';
COMMENT ON COLUMN rtsa.user_config.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.user_data.data IS '数据';
COMMENT ON COLUMN rtsa.user_data.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.user_data.updated_at IS '更新时间';
-- 创建用户操作日志表
CREATE TABLE
rtsa.user_operation_log (
id SERIAL PRIMARY KEY, -- id 自增主键
organization_id INT NOT NULL, -- 组织id
user_id INT NOT NULL, -- 用户id
log_type INT NOT NULL, -- 日志类型
log_data JSONB NOT NULL, -- 日志数据
created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP, -- 创建时间
FOREIGN KEY (organization_id) REFERENCES rtsa.organization (id) ON DELETE CASCADE, -- 组织外键
FOREIGN KEY (user_id) REFERENCES rtsa.user (id) ON DELETE CASCADE -- 用户外键
);
-- 创建用户操作日志组织索引
CREATE INDEX ON rtsa.user_operation_log (organization_id);
-- 创建用户操作日志用户索引
CREATE INDEX ON rtsa.user_operation_log (user_id);
-- 创建用户操作日志类型索引
CREATE INDEX ON rtsa.user_operation_log (log_type);
-- 创建用户操作日志数据索引
CREATE INDEX ON rtsa.user_operation_log USING GIN (log_data);
-- 创建用户操作日志索引
CREATE INDEX ON rtsa.user_operation_log (organization_id, user_id, log_type, created_at);
-- 注释用户操作日志表
COMMENT ON TABLE rtsa.user_operation_log IS '用户操作日志表';
-- 注释用户操作日志表字段
COMMENT ON COLUMN rtsa.user_operation_log.id IS 'id 自增主键';
COMMENT ON COLUMN rtsa.user_operation_log.organization_id IS '组织id';
COMMENT ON COLUMN rtsa.user_operation_log.user_id IS '用户id';
COMMENT ON COLUMN rtsa.user_operation_log.log_type IS '日志类型';
COMMENT ON COLUMN rtsa.user_operation_log.log_data IS '日志记录数据';
COMMENT ON COLUMN rtsa.user_operation_log.created_at IS '创建时间';
COMMENT ON COLUMN rtsa.user_config.updated_at IS '更新时间';

2
rtsa-proto-msg

@ -1 +1 @@
Subproject commit 867c075833ffbe64b0291db921adddc9d5d5a7a3
Subproject commit 1f53057b3f87790ef27c91399a5bb7e890f05549