init

src/routes/group/domain.rs

@@ -1 +1,2 @@
-pub struct Group {}
+// Ce fichier est conservé pour structure mais n'est plus utilisé.
+// Les modèles de domaine sont directement gérés par SeaORM dans src/models.

src/routes/group/dto.rs

@@ -1,10 +1,38 @@
+use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use uuid::Uuid;
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct CreateGroupRequest {}
+#[derive(Debug, Serialize, Deserialize, ToSchema)]
+pub struct CreateGroupRequest {
+    pub server_id: Uuid,
+    #[schema(example = "Modérateurs")]
+    pub name: String,
+    #[serde(default)]
+    pub is_default: bool,
+    pub server_permissions: i64,
+    pub channel_permissions: i64,
+    pub voice_permissions: i64,
+}
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct UpdateGroupRequest {}
+#[derive(Debug, Serialize, Deserialize, ToSchema)]
+pub struct UpdateGroupRequest {
+    #[schema(example = "Modérateurs (MAJ)")]
+    pub name: String,
+    pub is_default: bool,
+    pub server_permissions: i64,
+    pub channel_permissions: i64,
+    pub voice_permissions: i64,
+}
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct GroupResponse {}
+#[derive(Debug, Serialize, Deserialize, ToSchema)]
+pub struct GroupResponse {
+    pub id: Uuid,
+    pub server_id: Uuid,
+    pub name: String,
+    pub is_default: bool,
+    pub created_at: DateTime<Utc>,
+    pub server_permissions: i64,
+    pub channel_permissions: i64,
+    pub voice_permissions: i64,
+}

src/routes/group/handlers.rs

@@ -1,22 +1,153 @@
-use axum::http::StatusCode;
-use axum::response::IntoResponse;
+use crate::core::state::AppState;
+use crate::http::context::Superuser;
+use crate::http::error::HTTPError;
+use crate::routes::group::dto::{CreateGroupRequest, GroupResponse, UpdateGroupRequest};
+use crate::routes::group::mapper;
+use axum::{
+    Json,
+    extract::{Path, State},
+    http::StatusCode,
+};
+use uuid::Uuid;
 
-pub async fn get_all() -> impl IntoResponse {
-    StatusCode::NOT_IMPLEMENTED
+/// Liste tous les groupes
+#[utoipa::path(
+    get,
+    path = "/groups",
+    responses(
+        (status = 200, description = "Liste des groupes récupérée avec succès", body = [GroupResponse]),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Groups"
+)]
+pub async fn get_all(State(state): State<AppState>) -> Result<Json<Vec<GroupResponse>>, HTTPError> {
+    let groups = state.repositories.group.get_all().await?;
+    Ok(Json(
+        groups
+            .into_iter()
+            .map(mapper::group_model_to_group_response)
+            .collect(),
+    ))
 }
 
-pub async fn get_by_id() -> impl IntoResponse {
-    StatusCode::NOT_IMPLEMENTED
+/// Récupère un groupe par son ID
+#[utoipa::path(
+    get,
+    path = "/groups/{id}",
+    responses(
+        (status = 200, description = "Groupe trouvé", body = GroupResponse),
+        (status = 404, description = "Groupe non trouvé"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    params(
+        ("id" = Uuid, Path, description = "ID du groupe")
+    ),
+    tag = "Groups"
+)]
+pub async fn get_by_id(
+    State(state): State<AppState>,
+    Path(id): Path<Uuid>,
+) -> Result<Json<GroupResponse>, HTTPError> {
+    let group = state
+        .repositories
+        .group
+        .get_by_id(id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    Ok(Json(mapper::group_model_to_group_response(group)))
 }
 
-pub async fn create() -> impl IntoResponse {
-    StatusCode::NOT_IMPLEMENTED
+/// Crée un nouveau groupe
+#[utoipa::path(
+    post,
+    path = "/groups",
+    request_body = CreateGroupRequest,
+    responses(
+        (status = 201, description = "Groupe créé avec succès", body = GroupResponse),
+        (status = 404, description = "Serveur non trouvé"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Groups"
+)]
+pub async fn create(
+    _admin: Superuser,
+    State(state): State<AppState>,
+    Json(payload): Json<CreateGroupRequest>,
+) -> Result<(StatusCode, Json<GroupResponse>), HTTPError> {
+    // Vérifier que le serveur existe
+    state
+        .repositories
+        .server
+        .get_by_id(payload.server_id)
+        .await?
+        .ok_or(HTTPError::BadRequest("Server not found".to_string()))?;
+
+    let active_model = mapper::create_request_to_am(payload);
+    let group = state.repositories.group.create(active_model).await?;
+    Ok((
+        StatusCode::CREATED,
+        Json(mapper::group_model_to_group_response(group)),
+    ))
 }
 
-pub async fn update() -> impl IntoResponse {
-    StatusCode::NOT_IMPLEMENTED
+/// Met à jour un groupe existant
+#[utoipa::path(
+    put,
+    path = "/groups/{id}",
+    request_body = UpdateGroupRequest,
+    responses(
+        (status = 200, description = "Groupe mis à jour avec succès", body = GroupResponse),
+        (status = 404, description = "Groupe non trouvé"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    params(
+        ("id" = Uuid, Path, description = "ID du groupe")
+    ),
+    tag = "Groups"
+)]
+pub async fn update(
+    _admin: Superuser,
+    State(state): State<AppState>,
+    Path(id): Path<Uuid>,
+    Json(payload): Json<UpdateGroupRequest>,
+) -> Result<Json<GroupResponse>, HTTPError> {
+    // Vérifier l'existence
+    let group = state
+        .repositories
+        .group
+        .get_by_id(id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    let active_model = mapper::update_request_to_am(group.id, group.server_id, payload);
+    let group = state.repositories.group.update(active_model).await?;
+
+    Ok(Json(mapper::group_model_to_group_response(group)))
 }
 
-pub async fn delete() -> impl IntoResponse {
-    StatusCode::NOT_IMPLEMENTED
+/// Supprime un groupe
+#[utoipa::path(
+    delete,
+    path = "/groups/{id}",
+    responses(
+        (status = 204, description = "Groupe supprimé avec succès"),
+        (status = 404, description = "Groupe non trouvé"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    params(
+        ("id" = Uuid, Path, description = "ID du groupe")
+    ),
+    tag = "Groups"
+)]
+pub async fn delete(
+    _admin: Superuser,
+    State(state): State<AppState>,
+    Path(id): Path<Uuid>,
+) -> Result<StatusCode, HTTPError> {
+    if state.repositories.group.delete(id).await? {
+        Ok(StatusCode::NO_CONTENT)
+    } else {
+        Err(HTTPError::NotFound)
+    }
 }

src/routes/group/mapper.rs

@@ -1,5 +1,47 @@
-use super::{domain::Group, dto::GroupResponse};
+use crate::models::group;
+use crate::routes::group::dto::{CreateGroupRequest, GroupResponse, UpdateGroupRequest};
+use sea_orm::Set;
+use uuid::Uuid;
 
-pub fn to_response(_item: Group) -> GroupResponse {
-    todo!()
+pub fn group_model_to_group_response(model: group::Model) -> GroupResponse {
+    GroupResponse {
+        id: model.id,
+        server_id: model.server_id,
+        name: model.name,
+        is_default: model.is_default,
+        created_at: model.created_at,
+        server_permissions: model.server_permissions,
+        channel_permissions: model.channel_permissions,
+        voice_permissions: model.voice_permissions,
+    }
+}
+
+pub fn create_request_to_am(req: CreateGroupRequest) -> group::ActiveModel {
+    group::ActiveModel {
+        id: Set(Uuid::new_v4()),
+        server_id: Set(req.server_id),
+        name: Set(req.name),
+        is_default: Set(req.is_default),
+        server_permissions: Set(req.server_permissions),
+        channel_permissions: Set(req.channel_permissions),
+        voice_permissions: Set(req.voice_permissions),
+        ..Default::default()
+    }
+}
+
+pub fn update_request_to_am(
+    id: Uuid,
+    server_id: Uuid,
+    req: UpdateGroupRequest,
+) -> group::ActiveModel {
+    group::ActiveModel {
+        id: Set(id),
+        server_id: Set(server_id),
+        name: Set(req.name),
+        is_default: Set(req.is_default),
+        server_permissions: Set(req.server_permissions),
+        channel_permissions: Set(req.channel_permissions),
+        voice_permissions: Set(req.voice_permissions),
+        ..Default::default()
+    }
 }

src/routes/group/routes.rs

@@ -1,8 +1,9 @@
-use axum::{Router, routing::get};
+use crate::core::state::AppState;
+use axum::{routing::get, Router};
 
 use super::handlers;
 
-pub fn router() -> Router {
+pub fn router() -> Router<AppState> {
     Router::new()
         .route("/groups", get(handlers::get_all).post(handlers::create))
         .route(

src/routes/group/service.rs

@@ -1,21 +1,2 @@
-use super::domain::Group;
-
-pub async fn find_all() -> Vec<Group> {
-    todo!()
-}
-
-pub async fn find_by_id(_id: u64) -> Option<Group> {
-    todo!()
-}
-
-pub async fn create(_item: Group) -> Group {
-    todo!()
-}
-
-pub async fn update(_id: u64, _item: Group) -> Option<Group> {
-    todo!()
-}
-
-pub async fn delete(_id: u64) -> bool {
-    todo!()
-}
+// Ce fichier est conservé pour structure mais n'est plus utilisé.
+// La logique a été déplacée directement dans les handlers.