🎨 refactor(server): standardize entity-related import patterns

Author: ByteByteBrew

server/api/src/admin/sys_domain_api.rs

@@ -6,7 +6,7 @@ use axum::{
 };
 use server_core::web::{error::AppError, page::PaginatedData, res::Res, validator::ValidatedForm};
 use server_service::admin::{
- sys_domain, CreateDomainInput, DomainPageRequest, SysDomainService, TDomainService,
+ CreateDomainInput, DomainPageRequest, SysDomainModel, SysDomainService, TDomainService,
  UpdateDomainInput,
 };
 
@@ -16,28 +16,28 @@ impl SysDomainApi {
  pub async fn get_paginated_domains(
  Query(params): Query<DomainPageRequest>,
  Extension(service): Extension<Arc<SysDomainService>>,
- ) -> Result<Res<PaginatedData<sys_domain::Model>>, AppError> {
+ ) -> Result<Res<PaginatedData<SysDomainModel>>, AppError> {
  service.find_paginated_domains(params).await.map(Res::new_data)
  }
 
  pub async fn create_domain(
  Extension(service): Extension<Arc<SysDomainService>>,
  ValidatedForm(input): ValidatedForm<CreateDomainInput>,
- ) -> Result<Res<sys_domain::Model>, AppError> {
+ ) -> Result<Res<SysDomainModel>, AppError> {
  service.create_domain(input).await.map(Res::new_data)
  }
 
  pub async fn get_domain(
  Path(id): Path<String>,
  Extension(service): Extension<Arc<SysDomainService>>,
- ) -> Result<Res<sys_domain::Model>, AppError> {
+ ) -> Result<Res<SysDomainModel>, AppError> {
  service.get_domain(&id).await.map(Res::new_data)
  }
 
  pub async fn update_domain(
  Extension(service): Extension<Arc<SysDomainService>>,
  ValidatedForm(input): ValidatedForm<UpdateDomainInput>,
- ) -> Result<Res<sys_domain::Model>, AppError> {
+ ) -> Result<Res<SysDomainModel>, AppError> {
  service.update_domain(input).await.map(Res::new_data)
  }
 

server/api/src/admin/sys_endpoint_api.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use axum::{extract::Query, Extension};
 use server_core::web::{error::AppError, page::PaginatedData, res::Res};
 use server_service::admin::{
- sys_endpoint, EndpointPageRequest, SysEndpointService, TEndpointService,
+ EndpointPageRequest, SysEndpointModel, SysEndpointService, TEndpointService,
 };
 
 pub struct SysEndpointApi;
@@ -12,7 +12,7 @@ impl SysEndpointApi {
  pub async fn get_paginated_endpoints(
  Query(params): Query<EndpointPageRequest>,
  Extension(service): Extension<Arc<SysEndpointService>>,
- ) -> Result<Res<PaginatedData<sys_endpoint::Model>>, AppError> {
+ ) -> Result<Res<PaginatedData<SysEndpointModel>>, AppError> {
  service.find_paginated_endpoints(params).await.map(Res::new_data)
  }
 }

server/api/src/admin/sys_menu_api.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use axum::{extract::Path, Extension};
 use server_core::web::{auth::User, error::AppError, res::Res, validator::ValidatedForm};
 use server_service::admin::{
- sys_menu, CreateMenuInput, MenuRoute, SysMenuService, TMenuService, UpdateMenuInput,
+ CreateMenuInput, MenuRoute, SysMenuModel, SysMenuService, TMenuService, UpdateMenuInput,
 };
 
 pub struct SysMenuApi;
@@ -19,22 +19,22 @@ impl SysMenuApi {
  Extension(service): Extension<Arc<SysMenuService>>,
  Extension(user): Extension<User>,
  ValidatedForm(input): ValidatedForm<CreateMenuInput>,
- ) -> Result<Res<sys_menu::Model>, AppError> {
+ ) -> Result<Res<SysMenuModel>, AppError> {
  service.create_menu(input, user).await.map(Res::new_data)
  }
 
  pub async fn get_menu(
  Path(id): Path<i32>,
  Extension(service): Extension<Arc<SysMenuService>>,
- ) -> Result<Res<sys_menu::Model>, AppError> {
+ ) -> Result<Res<SysMenuModel>, AppError> {
  service.get_menu(id).await.map(Res::new_data)
  }
 
  pub async fn update_menu(
  Extension(service): Extension<Arc<SysMenuService>>,
  Extension(user): Extension<User>,
  ValidatedForm(input): ValidatedForm<UpdateMenuInput>,
- ) -> Result<Res<sys_menu::Model>, AppError> {
+ ) -> Result<Res<SysMenuModel>, AppError> {
  service.update_menu(input, user).await.map(Res::new_data)
  }
 

server/api/src/admin/sys_role_api.rs

@@ -6,7 +6,7 @@ use axum::{
 };
 use server_core::web::{error::AppError, page::PaginatedData, res::Res, validator::ValidatedForm};
 use server_service::admin::{
- sys_role, CreateRoleInput, RolePageRequest, SysRoleService, TRoleService, UpdateRoleInput,
+ CreateRoleInput, RolePageRequest, SysRoleModel, SysRoleService, TRoleService, UpdateRoleInput,
 };
 
 pub struct SysRoleApi;
@@ -15,28 +15,28 @@ impl SysRoleApi {
  pub async fn get_paginated_roles(
  Query(params): Query<RolePageRequest>,
  Extension(service): Extension<Arc<SysRoleService>>,
- ) -> Result<Res<PaginatedData<sys_role::Model>>, AppError> {
+ ) -> Result<Res<PaginatedData<SysRoleModel>>, AppError> {
  service.find_paginated_roles(params).await.map(Res::new_data)
  }
 
  pub async fn create_role(
  Extension(service): Extension<Arc<SysRoleService>>,
  ValidatedForm(input): ValidatedForm<CreateRoleInput>,
- ) -> Result<Res<sys_role::Model>, AppError> {
+ ) -> Result<Res<SysRoleModel>, AppError> {
  service.create_role(input).await.map(Res::new_data)
  }
 
  pub async fn get_role(
  Path(id): Path<String>,
  Extension(service): Extension<Arc<SysRoleService>>,
- ) -> Result<Res<sys_role::Model>, AppError> {
+ ) -> Result<Res<SysRoleModel>, AppError> {
  service.get_role(&id).await.map(Res::new_data)
  }
 
  pub async fn update_role(
  Extension(service): Extension<Arc<SysRoleService>>,
  ValidatedForm(input): ValidatedForm<UpdateRoleInput>,
- ) -> Result<Res<sys_role::Model>, AppError> {
+ ) -> Result<Res<SysRoleModel>, AppError> {
  service.update_role(input).await.map(Res::new_data)
  }
 

server/model/src/admin/output/sys_user.rs

@@ -2,7 +2,7 @@ use chrono::NaiveDateTime;
 use sea_orm::FromQueryResult;
 use serde::Serialize;
 
-use crate::admin::entities::{sea_orm_active_enums::Status, sys_user};
+use crate::admin::entities::{sea_orm_active_enums::Status, sys_user::Model as SysUserModel};
 
 #[derive(Debug, FromQueryResult)]
 pub struct UserWithDomainAndOrgOutput {
@@ -32,8 +32,8 @@ pub struct UserWithoutPassword {
  pub updated_by: Option<String>,
 }
 
-impl From<sys_user::Model> for UserWithoutPassword {
- fn from(model: sys_user::Model) -> Self {
+impl From<SysUserModel> for UserWithoutPassword {
+ fn from(model: SysUserModel) -> Self {
  Self {
  id: model.id,
  domain: model.domain,

server/service/src/admin/events/access_token_event.rs

@@ -2,7 +2,7 @@ use chrono::Utc;
 use sea_orm::{ActiveModelTrait, DatabaseConnection, Set};
 use server_constant::definition::consts::TokenStatus;
 use server_core::web::error::AppError;
-use server_model::admin::entities::sys_tokens;
+use server_model::admin::entities::sys_tokens::ActiveModel as SysTokensActiveModel;
 use ulid::Ulid;
 
 pub struct AccessTokenEvent {
@@ -23,7 +23,7 @@ impl AccessTokenEvent {
  pub async fn handle(self, db: &DatabaseConnection) -> Result<(), AppError> {
  let now = Utc::now().naive_utc();
 
- sys_tokens::ActiveModel {
+ SysTokensActiveModel {
  id: Set(Ulid::new().to_string()),
  access_token: Set(self.access_token),
  refresh_token: Set(self.refresh_token),

server/service/src/admin/events/login_log_event.rs

@@ -1,7 +1,7 @@
 use chrono::Utc;
 use sea_orm::{ActiveModelTrait, DatabaseConnection, Set};
 use server_core::web::error::AppError;
-use server_model::admin::entities::sys_login_log;
+use server_model::admin::entities::sys_login_log::ActiveModel as SysLoginLogActiveModel;
 use ulid::Ulid;
 
 pub struct LoginLogEvent {
@@ -18,7 +18,7 @@ pub struct LoginLogEvent {
 
 impl LoginLogEvent {
  pub async fn handle(self, db: &DatabaseConnection) -> Result<(), AppError> {
- sys_login_log::ActiveModel {
+ SysLoginLogActiveModel {
  id: Set(Ulid::new().to_string()),
  user_id: Set(self.user_id),
  username: Set(self.username.clone()),

server/service/src/admin/mod.rs

@@ -2,7 +2,10 @@ pub use errors::*;
 pub use server_model::admin::{
  entities::{
  prelude::{SysDomain, SysEndpoint, SysMenu, SysRole, SysUser},
- sys_domain, sys_endpoint, sys_menu, sys_role, sys_user,
+ sys_domain::Model as SysDomainModel,
+ sys_endpoint::Model as SysEndpointModel,
+ sys_menu::Model as SysMenuModel,
+ sys_role::Model as SysRoleModel,
  },
  input::*,
  output::*,

server/service/src/admin/sys_auth_service.rs

@@ -14,11 +14,12 @@ use server_model::admin::{
  entities::{
  prelude::{SysRole, SysUser},
  sea_orm_active_enums::Status,
- sys_domain,
- sys_menu::{self},
- sys_role, sys_role_menu,
- sys_user::{self},
- sys_user_role,
+ sys_domain::Column as SysDomainColumn,
+ sys_menu::{Column as SysMenuColumn, Entity as SysMenuEntity, Model as SysMenuModel},
+ sys_role::{Column as SysRoleColumn, Entity as SysRoleEntity, Relation as SysRoleRelation},
+ sys_role_menu::{Column as SysRoleMenuColumn, Entity as SysRoleMenuEntity},
+ sys_user::{Column as SysUserColumn, Relation as SysUserRelation},
+ sys_user_role::Relation as SysUserRoleRelation,
  },
  input::LoginInput,
  output::{AuthOutput, MenuRoute, RouteMeta, UserRoute, UserWithDomainAndOrgOutput},
@@ -42,14 +43,14 @@ macro_rules! select_user_with_domain_and_org_info {
  ($query:expr) => {{
  $query
  .select_only()
- .column_as(sys_user::Column::Id, "id")
- .column_as(sys_user::Column::Domain, "domain")
- .column_as(sys_user::Column::Username, "username")
- .column_as(sys_user::Column::Password, "password")
- .column_as(sys_user::Column::NickName, "nick_name")
- .column_as(sys_user::Column::Avatar, "avatar")
- .column_as(sys_domain::Column::Code, "domain_code")
- .column_as(sys_domain::Column::Name, "domain_name")
+ .column_as(SysUserColumn::Id, "id")
+ .column_as(SysUserColumn::Domain, "domain")
+ .column_as(SysUserColumn::Username, "username")
+ .column_as(SysUserColumn::Password, "password")
+ .column_as(SysUserColumn::NickName, "nick_name")
+ .column_as(SysUserColumn::Avatar, "avatar")
+ .column_as(SysDomainColumn::Code, "domain_code")
+ .column_as(SysDomainColumn::Name, "domain_name")
  }};
 }
 #[derive(Error, Debug)]
@@ -139,22 +140,22 @@ impl TAuthService for SysAuthService {
 
  let db = db_helper::get_db_connection().await?;
 
- let menu_ids = sys_role_menu::Entity::find()
+ let menu_ids = SysRoleMenuEntity::find()
  .select_only()
- .column(sys_role_menu::Column::MenuId)
- .join_rev(JoinType::InnerJoin, sys_role::Entity::has_many(sys_role_menu::Entity).into())
- .filter(sys_role::Column::Code.is_in(role_codes.to_vec()))
- .filter(sys_role_menu::Column::Domain.eq(domain))
+ .column(SysRoleMenuColumn::MenuId)
+ .join_rev(JoinType::InnerJoin, SysRoleEntity::has_many(SysRoleMenuEntity).into())
+ .filter(SysRoleColumn::Code.is_in(role_codes.to_vec()))
+ .filter(SysRoleMenuColumn::Domain.eq(domain))
  .distinct()
  .into_tuple::<i32>()
  .all(db.as_ref())
  .await?;
 
- let menus = sys_menu::Entity::find()
- .filter(sys_menu::Column::Id.is_in(menu_ids))
- .filter(sys_menu::Column::Status.eq(Status::Enabled))
- .order_by_asc(sys_menu::Column::Sequence)
- .into_model::<sys_menu::Model>()
+ let menus = SysMenuEntity::find()
+ .filter(SysMenuColumn::Id.is_in(menu_ids))
+ .filter(SysMenuColumn::Status.eq(Status::Enabled))
+ .order_by_asc(SysMenuColumn::Sequence)
+ .into_model::<SysMenuModel>()
  .all(db.as_ref())
  .await?;
 
@@ -220,9 +221,9 @@ impl SysAuthService {
  let db = db_helper::get_db_connection().await?;
 
  let user = select_user_with_domain_and_org_info!(SysUser::find())
- .filter(sys_user::Column::Username.eq(identifier))
- .filter(sys_domain::Column::Code.eq(domain))
- .join(JoinType::InnerJoin, sys_user::Relation::SysDomain.def())
+ .filter(SysUserColumn::Username.eq(identifier))
+ .filter(SysDomainColumn::Code.eq(domain))
+ .join(JoinType::InnerJoin, SysUserRelation::SysDomain.def())
  .into_model::<UserWithDomainAndOrgOutput>()
  .one(db.as_ref())
  .await
@@ -249,9 +250,9 @@ impl SysAuthService {
  db: &DatabaseConnection,
  ) -> Result<Vec<String>, AppError> {
  SysRole::find()
- .join(JoinType::InnerJoin, sys_role::Relation::SysUserRole.def())
- .join(JoinType::InnerJoin, sys_user_role::Relation::SysUser.def())
- .filter(sys_user::Column::Id.eq(user_id))
+ .join(JoinType::InnerJoin, SysRoleRelation::SysUserRole.def())
+ .join(JoinType::InnerJoin, SysUserRoleRelation::SysUser.def())
+ .filter(SysUserColumn::Id.eq(user_id))
  .all(db)
  .await
  .map(|roles| roles.iter().map(|role| role.code.clone()).collect())