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/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