oxpanel/oxspeak_server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
Nell
2026-08-02 12:07:51 +02:00
parent aa486be6e5
commit bb4e17ba2f
15 changed files with 502 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/domain/dto/role.rs
+5
View File
@@ -3,6 +3,11 @@ use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use uuid::Uuid;
#[derive(Debug, Serialize, Deserialize, ToSchema, utoipa::IntoParams)]
pub struct RoleQueryParams {
pub server_id: Option<Uuid>,
}
#[derive(Debug, Serialize, Deserialize, ToSchema)]
pub struct CreateRoleRequest {
pub server_id: Uuid,
src/repositories/role.rs
+46 -1
View File
@@ -1,4 +1,4 @@
use crate::models::{role, role_user};
use crate::models::{role, role_user, user};
use crate::repositories::{AnyResult, RepositoryContext};
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
use std::sync::Arc;
@@ -63,4 +63,49 @@ impl RoleRepository {
.await?;
Ok(res.rows_affected > 0)
}
pub async fn get_members(&self, role_id: Uuid) -> AnyResult<Vec<user::Model>> {
let memberships = role_user::Entity::find()
.filter(role_user::Column::RoleId.eq(role_id))
.all(&self.context.db)
.await?;
let mut members = Vec::with_capacity(memberships.len());
for membership in memberships {
if let Some(user) = user::Entity::find_by_id(membership.user_id)
.one(&self.context.db)
.await?
{
members.push(user);
}
}
Ok(members)
}
pub async fn add_member(&self, role_id: Uuid, user_id: Uuid) -> AnyResult<bool> {
if role_user::Entity::find_by_id((role_id, user_id))
.one(&self.context.db)
.await?
.is_some()
{
return Ok(false);
}
role_user::ActiveModel {
role_id: Set(role_id),
user_id: Set(user_id),
}
.insert(&self.context.db)
.await?;
Ok(true)
}
pub async fn remove_member(&self, role_id: Uuid, user_id: Uuid) -> AnyResult<bool> {
let result = role_user::Entity::delete_by_id((role_id, user_id))
.exec(&self.context.db)
.await?;
Ok(result.rows_affected > 0)
}
}
src/repositories/server.rs
+8
View File
@@ -84,6 +84,14 @@ impl ServerRepository {
Ok(true)
}
pub async fn get_user(&self, server_id: Uuid, user_id: Uuid) -> AnyResult<Option<server_user::Model>> {
Ok(server_user::Entity::find()
.filter(server_user::Column::ServerId.eq(server_id))
.filter(server_user::Column::UserId.eq(user_id))
.one(&self.context.db)
.await?)
}
pub async fn delete(&self, id: Uuid) -> AnyResult<bool> {
let res = server::Entity::delete_by_id(id)
.exec(&self.context.db)
src/routes/role/handlers.rs
+97 -128
View File
@@ -1,162 +1,131 @@
use crate::core::state::AppState;
use crate::http::context::Superuser;
use crate::domain::dto::role::{CreateRoleRequest, RoleQueryParams, RoleResponse, UpdateRoleRequest};
use crate::domain::dto::user::UserResponse;
use crate::http::context::CurrentUser;
use crate::http::error::HTTPError;
use crate::domain::dto::role::{CreateRoleRequest, RoleResponse, UpdateRoleRequest};
use crate::permissions::ServerPermission;
use crate::routes::role::mapper;
use axum::{
Json,
extract::{Path, State},
http::StatusCode,
};
use crate::routes::user::mapper as user_mapper;
use axum::{Json, extract::{Path, Query, State}, http::StatusCode};
use uuid::Uuid;
/// Liste tous les groupes
#[utoipa::path(
get,
path = "/groups",
responses(
(status = 200, description = "Liste des groupes récupérée avec succès", body = [RoleResponse]),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Roles"
)]
pub async fn get_all(State(state): State<AppState>) -> Result<Json<Vec<RoleResponse>>, HTTPError> {
let groups = state.repositories.role.get_all().await?;
Ok(Json(
groups
.into_iter()
.map(mapper::group_model_to_group_response)
.collect(),
))
async fn require_permission(
state: &AppState,
user: &CurrentUser,
server_id: Uuid,
permission: ServerPermission,
) -> Result<(), HTTPError> {
if user.is_superuser {
return Ok(());
}
let granted = state
.repositories
.server
.get_user_permission(server_id, user.id)
.await?
.map(|value| ServerPermission::from_bits_truncate(value.permissions as u64))
.unwrap_or_default();
if granted.contains(permission) {
Ok(())
} else {
Err(HTTPError::Forbidden)
}
}
/// Récupère un groupe par son ID
#[utoipa::path(
get,
path = "/groups/{id}",
responses(
(status = 200, description = "Rolee trouvé", body = RoleResponse),
(status = 404, description = "Rolee non trouvé"),
(status = 500, description = "Erreur interne du serveur")
),
params(
("id" = Uuid, Path, description = "ID du groupe")
),
tag = "Roles"
)]
#[utoipa::path(get, path = "/roles", params(RoleQueryParams), responses((status = 200, body = [RoleResponse])), tag = "Roles")]
pub async fn get_all(
State(state): State<AppState>,
Query(filters): Query<RoleQueryParams>,
) -> Result<Json<Vec<RoleResponse>>, HTTPError> {
let roles = match filters.server_id {
Some(server_id) => state.repositories.role.get_all_by_server(server_id).await?,
None => state.repositories.role.get_all().await?,
};
Ok(Json(roles.into_iter().map(mapper::role_model_to_role_response).collect()))
}
#[utoipa::path(get, path = "/roles/{id}", params(("id" = Uuid, Path)), responses((status = 200, body = RoleResponse), (status = 404)), tag = "Roles")]
pub async fn get_by_id(
State(state): State<AppState>,
Path(id): Path<Uuid>,
) -> Result<Json<RoleResponse>, HTTPError> {
let group = state
.repositories
.role
.get_by_id(id)
.await?
.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::group_model_to_group_response(group)))
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
Ok(Json(mapper::role_model_to_role_response(role)))
}
/// Crée un nouveau groupe
#[utoipa::path(
post,
path = "/groups",
request_body = CreateRoleRequest,
responses(
(status = 201, description = "Role créé avec succès", body = RoleResponse),
(status = 404, description = "Serveur non trouvé"),
(status = 500, description = "Erreur interne du serveur")
),
tag = "Roles",
security(
("bearerAuth" = [])
)
)]
#[utoipa::path(post, path = "/roles", request_body = CreateRoleRequest, responses((status = 201, body = RoleResponse)), tag = "Roles", security(("bearerAuth" = [])))]
pub async fn create(
_admin: Superuser,
user: CurrentUser,
State(state): State<AppState>,
Json(payload): Json<CreateRoleRequest>,
) -> Result<(StatusCode, Json<RoleResponse>), HTTPError> {
// Vérifier que le serveur existe
state
.repositories
.server
.get_by_id(payload.server_id)
.await?
state.repositories.server.get_by_id(payload.server_id).await?
.ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
require_permission(&state, &user, payload.server_id, ServerPermission::MANAGE_ROLES).await?;
let active_model = mapper::create_request_to_am(payload);
let group = state.services.role.create_role(active_model).await?;
Ok((
StatusCode::CREATED,
Json(mapper::group_model_to_group_response(group)),
))
let role = state.services.role.create_role(mapper::create_request_to_am(payload)).await?;
Ok((StatusCode::CREATED, Json(mapper::role_model_to_role_response(role))))
}
/// Met à jour un groupe existant
#[utoipa::path(
put,
path = "/groups/{id}",
request_body = UpdateRoleRequest,
responses(
(status = 200, description = "Role mis à jour avec succès", body = RoleResponse),
(status = 404, description = "Role non trouvé"),
(status = 500, description = "Erreur interne du serveur")
),
params(
("id" = Uuid, Path, description = "ID du groupe")
),
tag = "Roles",
security(
("bearerAuth" = [])
)
)]
#[utoipa::path(put, path = "/roles/{id}", request_body = UpdateRoleRequest, responses((status = 200, body = RoleResponse), (status = 404)), tag = "Roles", security(("bearerAuth" = [])))]
pub async fn update(
_admin: Superuser,
user: CurrentUser,
State(state): State<AppState>,
Path(id): Path<Uuid>,
Json(payload): Json<UpdateRoleRequest>,
) -> Result<Json<RoleResponse>, HTTPError> {
// Vérifier l'existence
let group = state
.repositories
.role
.get_by_id(id)
.await?
.ok_or(HTTPError::NotFound)?;
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
require_permission(&state, &user, role.server_id, ServerPermission::MANAGE_ROLES).await?;
let active_model = mapper::update_request_to_am(group.id, group.server_id, payload);
let group = state.services.role.update_role(active_model).await?;
Ok(Json(mapper::group_model_to_group_response(group)))
let role = state.services.role.update_role(mapper::update_request_to_am(role.id, role.server_id, payload)).await?;
Ok(Json(mapper::role_model_to_role_response(role)))
}
/// Supprime un groupe
#[utoipa::path(
delete,
path = "/groups/{id}",
responses(
(status = 204, description = "Role supprimé avec succès"),
(status = 404, description = "Role non trouvé"),
(status = 500, description = "Erreur interne du serveur")
),
params(
("id" = Uuid, Path, description = "ID du groupe")
),
tag = "Roles",
security(
("bearerAuth" = [])
)
)]
#[utoipa::path(delete, path = "/roles/{id}", responses((status = 204), (status = 404)), tag = "Roles", security(("bearerAuth" = [])))]
pub async fn delete(
_admin: Superuser,
user: CurrentUser,
State(state): State<AppState>,
Path(id): Path<Uuid>,
) -> Result<StatusCode, HTTPError> {
if state.services.role.delete_role(id).await? {
Ok(StatusCode::NO_CONTENT)
} else {
Err(HTTPError::NotFound)
}
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
require_permission(&state, &user, role.server_id, ServerPermission::MANAGE_ROLES).await?;
if state.services.role.delete_role(id).await? { Ok(StatusCode::NO_CONTENT) } else { Err(HTTPError::NotFound) }
}
pub async fn get_members(
user: CurrentUser,
State(state): State<AppState>,
Path(id): Path<Uuid>,
) -> Result<Json<Vec<UserResponse>>, HTTPError> {
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
require_permission(&state, &user, role.server_id, ServerPermission::MANAGE_MEMBERS).await?;
let members = state.repositories.role.get_members(id).await?;
Ok(Json(members.into_iter().map(user_mapper::user_model_to_user_response).collect()))
}
pub async fn add_member(
user: CurrentUser,
State(state): State<AppState>,
Path((id, user_id)): Path<(Uuid, Uuid)>,
) -> Result<StatusCode, HTTPError> {
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
require_permission(&state, &user, role.server_id, ServerPermission::MANAGE_MEMBERS).await?;
state.repositories.server.get_user(role.server_id, user_id).await?
.ok_or(HTTPError::BadRequest("User is not a member of this server".to_string()))?;
state.services.role.add_member(id, user_id, role.server_id).await?;
Ok(StatusCode::NO_CONTENT)
}
pub async fn remove_member(
user: CurrentUser,
State(state): State<AppState>,
Path((id, user_id)): Path<(Uuid, Uuid)>,
) -> Result<StatusCode, HTTPError> {
let role = state.repositories.role.get_by_id(id).await?.ok_or(HTTPError::NotFound)?;
require_permission(&state, &user, role.server_id, ServerPermission::MANAGE_MEMBERS).await?;
if state.services.role.remove_member(id, user_id, role.server_id).await? { Ok(StatusCode::NO_CONTENT) } else { Err(HTTPError::NotFound) }
}
src/routes/role/mapper.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use crate::domain::dto::role::{CreateRoleRequest, RoleResponse, UpdateRoleReques
use sea_orm::Set;
use uuid::Uuid;
pub fn group_model_to_group_response(model: role::Model) -> RoleResponse {
pub fn role_model_to_role_response(model: role::Model) -> RoleResponse {
RoleResponse {
id: model.id,
server_id: model.server_id,
src/routes/role/routes.rs
+5 -3
View File
@@ -1,15 +1,17 @@
use crate::core::state::AppState;
use axum::{routing::get, Router};
use axum::{routing::{get, put}, Router};
use super::handlers;
pub fn router() -> Router<AppState> {
Router::new()
.route("/groups", get(handlers::get_all).post(handlers::create))
.route("/roles", get(handlers::get_all).post(handlers::create))
.route(
"/groups/{id}",
"/roles/{id}",
get(handlers::get_by_id)
.put(handlers::update)
.delete(handlers::delete),
)
.route("/roles/{id}/members", get(handlers::get_members))
.route("/roles/{id}/members/{user_id}", put(handlers::add_member).delete(handlers::remove_member))
}
src/routes/server/handlers.rs
+29 -1
View File
@@ -5,6 +5,7 @@ use crate::domain::dto::server::{
};
use crate::http::context::{CurrentUser, Superuser};
use crate::http::error::HTTPError;
use crate::permissions::ServerPermission;
use crate::routes::server::mapper;
use axum::{
Json,
@@ -13,6 +14,27 @@ use axum::{
};
use uuid::Uuid;
async fn require_server_permission(
state: &AppState,
user: &CurrentUser,
server_id: Uuid,
permission: ServerPermission,
) -> Result<(), HTTPError> {
if user.is_superuser {
return Ok(());
}
let granted = state
.repositories
.server
.get_user_permission(server_id, user.id)
.await?
.map(|value| ServerPermission::from_bits_truncate(value.permissions as u64))
.unwrap_or_default();
if granted.contains(permission) { Ok(()) } else { Err(HTTPError::Forbidden) }
}
/// Liste tous les serveurs
#[utoipa::path(
get,
@@ -112,7 +134,7 @@ pub async fn create(
)
)]
pub async fn update(
_admin: Superuser,
user: CurrentUser,
State(state): State<AppState>,
Path(id): Path<Uuid>,
Json(payload): Json<UpdateServerRequest>,
@@ -125,6 +147,8 @@ pub async fn update(
.await?
.ok_or(HTTPError::NotFound)?;
require_server_permission(&state, &user, id, ServerPermission::MANAGE_SERVER).await?;
let server = state
.services
.server
@@ -311,10 +335,12 @@ pub async fn get_role_permission(
tag = "Server Permissions"
)]
pub async fn set_role_permission(
user: CurrentUser,
State(state): State<AppState>,
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
Json(payload): Json<SetServerPermissionRequest>,
) -> Result<Json<ServerRolePermissionResponse>, HTTPError> {
require_server_permission(&state, &user, server_id, ServerPermission::MANAGE_ROLES).await?;
state
.repositories
.server
@@ -347,9 +373,11 @@ pub async fn set_role_permission(
tag = "Server Permissions"
)]
pub async fn remove_role_permission(
user: CurrentUser,
State(state): State<AppState>,
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
) -> Result<StatusCode, HTTPError> {
require_server_permission(&state, &user, server_id, ServerPermission::MANAGE_ROLES).await?;
if state
.repositories
.server
src/services/role.rs
+28 -8
View File
@@ -1,6 +1,6 @@
use crate::services::ServicesContext;
use crate::models::role;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, TransactionTrait, Set};
use sea_orm::{ActiveModelTrait, EntityTrait, TransactionTrait};
use std::sync::Arc;
use uuid::Uuid;
@@ -23,13 +23,13 @@ impl RoleService {
let txn = db.begin().await?;
let group = active.insert(&txn).await?;
let role = active.insert(&txn).await?;
txn.commit().await?;
event_bus.emit("group_created", group.clone());
event_bus.emit("role_created", role.clone());
Ok(group)
Ok(role)
}
pub async fn update_role(
@@ -41,13 +41,13 @@ impl RoleService {
let txn = db.begin().await?;
let group = active.update(&txn).await?;
let role = active.update(&txn).await?;
txn.commit().await?;
event_bus.emit("group_updated", group.clone());
event_bus.emit("role_updated", role.clone());
Ok(group)
Ok(role)
}
pub async fn delete_role(&self, id: Uuid) -> Result<bool, anyhow::Error> {
@@ -65,9 +65,29 @@ impl RoleService {
txn.commit().await?;
if deleted {
event_bus.emit("group_deleted", id);
event_bus.emit("role_deleted", id);
}
Ok(deleted)
}
pub async fn add_member(&self, role_id: Uuid, user_id: Uuid, server_id: Uuid) -> Result<bool, anyhow::Error> {
let added = self.service_context.repositories.role.add_member(role_id, user_id).await?;
if added {
self.service_context
.event_bus
.emit("role_user_created", (role_id, user_id, server_id));
}
Ok(added)
}
pub async fn remove_member(&self, role_id: Uuid, user_id: Uuid, server_id: Uuid) -> Result<bool, anyhow::Error> {
let removed = self.service_context.repositories.role.remove_member(role_id, user_id).await?;
if removed {
self.service_context
.event_bus
.emit("role_user_deleted", (role_id, user_id, server_id));
}
Ok(removed)
}
}