511 lines
15 KiB
Rust
511 lines
15 KiB
Rust
use crate::core::state::AppState;
|
|
use crate::domain::dto::server::{
|
|
CreateServerRequest, ServerResponse, ServerRolePermissionResponse, ServerTreeResponse,
|
|
ServerUserPermissionResponse, SetServerPermissionRequest, UpdateServerRequest,
|
|
};
|
|
use crate::http::context::{CurrentUser, Superuser};
|
|
use crate::http::error::HTTPError;
|
|
use crate::permissions::ServerPermission;
|
|
use crate::routes::server::mapper;
|
|
use axum::{
|
|
Json,
|
|
extract::{Path, State},
|
|
http::StatusCode,
|
|
};
|
|
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,
|
|
path = "/servers",
|
|
responses(
|
|
(status = 200, description = "Liste des serveurs récupérée avec succès", body = [ServerResponse]),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
security(("bearerAuth" = [])),
|
|
tag = "Servers"
|
|
)]
|
|
pub async fn get_all(
|
|
user: CurrentUser,
|
|
State(state): State<AppState>,
|
|
) -> Result<Json<Vec<ServerResponse>>, HTTPError> {
|
|
let servers = state.repositories.server.get_all().await?;
|
|
let unread_counts = state
|
|
.repositories
|
|
.read_state
|
|
.unread_counts_by_server(user.id)
|
|
.await?;
|
|
Ok(Json(
|
|
servers
|
|
.into_iter()
|
|
.map(|server| {
|
|
let server_id = server.id;
|
|
mapper::server_model_to_server_response_with_unread_count(
|
|
server,
|
|
unread_counts.get(&server_id).copied().unwrap_or(0),
|
|
)
|
|
})
|
|
.collect(),
|
|
))
|
|
}
|
|
|
|
/// Récupère un serveur par son ID
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/servers/{id}",
|
|
responses(
|
|
(status = 200, description = "Serveur trouvé", body = ServerResponse),
|
|
(status = 404, description = "Serveur non trouvé"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du serveur")
|
|
),
|
|
tag = "Servers"
|
|
)]
|
|
pub async fn get_by_id(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<Json<ServerResponse>, HTTPError> {
|
|
let server = state
|
|
.repositories
|
|
.server
|
|
.get_by_id(id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::server_model_to_server_response(server)))
|
|
}
|
|
|
|
/// Crée un nouveau serveur
|
|
#[utoipa::path(
|
|
post,
|
|
path = "/servers",
|
|
request_body = CreateServerRequest,
|
|
responses(
|
|
(status = 201, description = "Serveur créé avec succès", body = ServerResponse),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Servers",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn create(
|
|
_admin: Superuser,
|
|
State(state): State<AppState>,
|
|
Json(payload): Json<CreateServerRequest>,
|
|
) -> Result<(StatusCode, Json<ServerResponse>), HTTPError> {
|
|
let server = state
|
|
.services
|
|
.server
|
|
.create_server(payload.name, payload.is_default)
|
|
.await?;
|
|
Ok((
|
|
StatusCode::CREATED,
|
|
Json(mapper::server_model_to_server_response(server)),
|
|
))
|
|
}
|
|
|
|
/// Met à jour un serveur existant
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/servers/{id}",
|
|
request_body = UpdateServerRequest,
|
|
responses(
|
|
(status = 200, description = "Serveur mis à jour avec succès", body = ServerResponse),
|
|
(status = 404, description = "Serveur non trouvé"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du serveur")
|
|
),
|
|
tag = "Servers",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn update(
|
|
user: CurrentUser,
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
Json(payload): Json<UpdateServerRequest>,
|
|
) -> Result<Json<ServerResponse>, HTTPError> {
|
|
// Vérifier l'existence
|
|
let _server = state
|
|
.repositories
|
|
.server
|
|
.get_by_id(id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
require_server_permission(&state, &user, id, ServerPermission::MANAGE_SERVER).await?;
|
|
|
|
let server = state
|
|
.services
|
|
.server
|
|
.update_server(id, payload.name, payload.is_default)
|
|
.await?;
|
|
|
|
Ok(Json(mapper::server_model_to_server_response(server)))
|
|
}
|
|
|
|
/// Supprime un serveur
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/servers/{id}",
|
|
responses(
|
|
(status = 204, description = "Serveur supprimé avec succès"),
|
|
(status = 404, description = "Serveur non trouvé"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("id" = Uuid, Path, description = "ID du serveur")
|
|
),
|
|
tag = "Servers",
|
|
security(
|
|
("bearerAuth" = [])
|
|
)
|
|
)]
|
|
pub async fn delete(
|
|
_admin: Superuser,
|
|
State(state): State<AppState>,
|
|
Path(id): Path<Uuid>,
|
|
) -> Result<StatusCode, HTTPError> {
|
|
if state.services.server.delete_server(id).await? {
|
|
Ok(StatusCode::NO_CONTENT)
|
|
} else {
|
|
Err(HTTPError::NotFound)
|
|
}
|
|
}
|
|
|
|
/// Récupère les permissions directes d'un utilisateur sur un serveur.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/servers/{server_id}/permissions/users/{user_id}",
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 200, body = ServerUserPermissionResponse),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Server Permissions"
|
|
)]
|
|
pub async fn get_user_permission(
|
|
State(state): State<AppState>,
|
|
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<Json<ServerUserPermissionResponse>, HTTPError> {
|
|
let permission = state
|
|
.repositories
|
|
.server
|
|
.get_user_permission(server_id, user_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::server_user_permission_to_response(permission)))
|
|
}
|
|
|
|
/// Liste les permissions directes des utilisateurs d'un serveur.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/servers/{server_id}/permissions/users",
|
|
params(("server_id" = Uuid, Path, description = "ID du serveur")),
|
|
responses((status = 200, body = [ServerUserPermissionResponse])),
|
|
tag = "Server Permissions"
|
|
)]
|
|
pub async fn list_user_permissions(
|
|
State(state): State<AppState>,
|
|
Path(server_id): Path<Uuid>,
|
|
) -> Result<Json<Vec<ServerUserPermissionResponse>>, HTTPError> {
|
|
state
|
|
.repositories
|
|
.server
|
|
.get_by_id(server_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
let permissions = state
|
|
.repositories
|
|
.server
|
|
.get_user_permissions(server_id)
|
|
.await?;
|
|
Ok(Json(
|
|
permissions
|
|
.into_iter()
|
|
.map(mapper::server_user_permission_to_response)
|
|
.collect(),
|
|
))
|
|
}
|
|
|
|
/// Définit ou remplace les permissions directes d'un utilisateur sur un serveur.
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/servers/{server_id}/permissions/users/{user_id}",
|
|
request_body = SetServerPermissionRequest,
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 200, body = ServerUserPermissionResponse),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Server Permissions"
|
|
)]
|
|
pub async fn set_user_permission(
|
|
user: CurrentUser,
|
|
State(state): State<AppState>,
|
|
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
|
|
Json(payload): Json<SetServerPermissionRequest>,
|
|
) -> Result<Json<ServerUserPermissionResponse>, HTTPError> {
|
|
require_server_permission(&state, &user, server_id, ServerPermission::MANAGE_MEMBERS).await?;
|
|
state
|
|
.repositories
|
|
.server
|
|
.get_user(server_id, user_id)
|
|
.await?
|
|
.ok_or(HTTPError::BadRequest(
|
|
"User is not a member of this server".to_string(),
|
|
))?;
|
|
state
|
|
.repositories
|
|
.server
|
|
.set_user_permission(server_id, user_id, payload.permissions)
|
|
.await?;
|
|
state
|
|
.event_bus
|
|
.emit("server_user_permission_updated", (server_id, user_id));
|
|
|
|
let permission = state
|
|
.repositories
|
|
.server
|
|
.get_user_permission(server_id, user_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::server_user_permission_to_response(permission)))
|
|
}
|
|
|
|
/// Supprime les permissions directes d'un utilisateur sur un serveur.
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/servers/{server_id}/permissions/users/{user_id}",
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("user_id" = Uuid, Path, description = "ID de l'utilisateur")
|
|
),
|
|
responses(
|
|
(status = 204, description = "Permission supprimée"),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Server Permissions"
|
|
)]
|
|
pub async fn remove_user_permission(
|
|
user: CurrentUser,
|
|
State(state): State<AppState>,
|
|
Path((server_id, user_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<StatusCode, HTTPError> {
|
|
require_server_permission(&state, &user, server_id, ServerPermission::MANAGE_MEMBERS).await?;
|
|
if state
|
|
.repositories
|
|
.server
|
|
.get_user_permission(server_id, user_id)
|
|
.await?
|
|
.is_none()
|
|
{
|
|
return Err(HTTPError::NotFound);
|
|
}
|
|
|
|
state
|
|
.repositories
|
|
.server
|
|
.remove_user_permission(server_id, user_id)
|
|
.await?;
|
|
state
|
|
.event_bus
|
|
.emit("server_user_permission_updated", (server_id, user_id));
|
|
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
/// Récupère les permissions d'un rôle sur un serveur.
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/servers/{server_id}/permissions/roles/{role_id}",
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 200, body = ServerRolePermissionResponse),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
tag = "Server Permissions"
|
|
)]
|
|
pub async fn get_role_permission(
|
|
State(state): State<AppState>,
|
|
Path((server_id, role_id)): Path<(Uuid, Uuid)>,
|
|
) -> Result<Json<ServerRolePermissionResponse>, HTTPError> {
|
|
let permission = state
|
|
.repositories
|
|
.server
|
|
.get_role_permission(server_id, role_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::server_role_permission_to_response(permission)))
|
|
}
|
|
|
|
/// Définit ou remplace les permissions d'un rôle sur un serveur.
|
|
#[utoipa::path(
|
|
put,
|
|
path = "/servers/{server_id}/permissions/roles/{role_id}",
|
|
request_body = SetServerPermissionRequest,
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 200, body = ServerRolePermissionResponse),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
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
|
|
.set_role_permission(server_id, role_id, payload.permissions)
|
|
.await?;
|
|
state
|
|
.event_bus
|
|
.emit("server_role_permission_updated", (role_id, server_id));
|
|
|
|
let permission = state
|
|
.repositories
|
|
.server
|
|
.get_role_permission(server_id, role_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
Ok(Json(mapper::server_role_permission_to_response(permission)))
|
|
}
|
|
|
|
/// Supprime les permissions d'un rôle sur un serveur.
|
|
#[utoipa::path(
|
|
delete,
|
|
path = "/servers/{server_id}/permissions/roles/{role_id}",
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur"),
|
|
("role_id" = Uuid, Path, description = "ID du rôle")
|
|
),
|
|
responses(
|
|
(status = 204, description = "Permission supprimée"),
|
|
(status = 404, description = "Permission introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
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
|
|
.get_role_permission(server_id, role_id)
|
|
.await?
|
|
.is_none()
|
|
{
|
|
return Err(HTTPError::NotFound);
|
|
}
|
|
|
|
state
|
|
.repositories
|
|
.server
|
|
.remove_role_permission(server_id, role_id)
|
|
.await?;
|
|
state
|
|
.event_bus
|
|
.emit("server_role_permission_updated", (role_id, server_id));
|
|
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get,
|
|
path = "/servers/{server_id}/tree",
|
|
responses(
|
|
(status = 200, description = "Arborescence du serveur récupérée avec succès"),
|
|
(status = 404, description = "Serveur introuvable"),
|
|
(status = 500, description = "Erreur interne du serveur")
|
|
),
|
|
params(
|
|
("server_id" = Uuid, Path, description = "ID du serveur")
|
|
),
|
|
tag = "Servers"
|
|
)]
|
|
pub async fn get_tree(
|
|
user: CurrentUser,
|
|
State(state): State<AppState>,
|
|
Path(server_id): Path<Uuid>,
|
|
) -> Result<Json<ServerTreeResponse>, HTTPError> {
|
|
// Vérifier l'existence du serveur
|
|
state
|
|
.repositories
|
|
.server
|
|
.get_by_id(server_id)
|
|
.await?
|
|
.ok_or(HTTPError::NotFound)?;
|
|
|
|
let tree = state
|
|
.repositories
|
|
.server_tree
|
|
.get_for_user(server_id, user.id)
|
|
.await?;
|
|
|
|
Ok(Json(mapper::build_server_tree(
|
|
tree.orders,
|
|
tree.channels,
|
|
tree.categories,
|
|
tree.unread_counts,
|
|
)))
|
|
}
|