init

migration/src/m20220101_000001_create_table.rs

@@ -481,6 +481,12 @@ impl MigrationTrait for Migration {
                 Table::create()
                     .table(Alias::new("server_user_permission"))
                     .if_not_exists()
+                    .col(
+                        ColumnDef::new(Alias::new("id"))
+                            .uuid()
+                            .not_null()
+                            .primary_key(),
+                    )
                     .col(ColumnDef::new(Alias::new("server_id")).uuid().not_null())
                     .col(ColumnDef::new(Alias::new("user_id")).uuid().not_null())
                     .col(

src/repositories/channel.rs

@@ -1,7 +1,9 @@
-use crate::models::channel;
+use crate::models::{channel, channel_role_permission, channel_user_permission};
 use crate::repositories::{AnyResult, RepositoryContext};
-use sea_orm::{ActiveModelTrait, EntityTrait};
+use sea_orm::sea_query::OnConflict;
+use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, Set};
 use std::sync::Arc;
+use uuid::Uuid;
 
 #[derive(Clone, Debug)]
 pub struct ChannelRepository {
@@ -9,7 +11,7 @@ pub struct ChannelRepository {
 }
 
 impl ChannelRepository {
-    pub async fn get_by_id(&self, id: uuid::Uuid) -> AnyResult<Option<channel::Model>> {
+    pub async fn get_by_id(&self, id: Uuid) -> AnyResult<Option<channel::Model>> {
         Ok(channel::Entity::find_by_id(id)
             .one(&self.context.db)
             .await?)
@@ -31,11 +33,111 @@ impl ChannelRepository {
         Ok(channel)
     }
 
-    pub async fn delete(&self, id: uuid::Uuid) -> AnyResult<bool> {
+    pub async fn delete(&self, id: Uuid) -> AnyResult<bool> {
         let res = channel::Entity::delete_by_id(id)
             .exec(&self.context.db)
             .await?;
         self.context.events.emit("channel_deleted", id);
         Ok(res.rows_affected > 0)
     }
+
+    pub async fn get_user_permission(
+        &self,
+        channel_id: Uuid,
+        user_id: Uuid,
+    ) -> AnyResult<Option<channel_user_permission::Model>> {
+        Ok(channel_user_permission::Entity::find()
+            .filter(channel_user_permission::Column::ChannelId.eq(channel_id))
+            .filter(channel_user_permission::Column::UserId.eq(user_id))
+            .one(&self.context.db)
+            .await?)
+    }
+
+    pub async fn set_user_permission(
+        &self,
+        channel_id: Uuid,
+        user_id: Uuid,
+        permissions: u64,
+    ) -> AnyResult<()> {
+        let permission = channel_user_permission::ActiveModel {
+            channel_id: Set(channel_id),
+            user_id: Set(user_id),
+            permissions: Set(permissions as i64),
+            ..Default::default()
+        };
+
+        channel_user_permission::Entity::insert(permission)
+            .on_conflict(
+                OnConflict::columns([
+                    channel_user_permission::Column::ChannelId,
+                    channel_user_permission::Column::UserId,
+                ])
+                .update_columns([channel_user_permission::Column::Permissions])
+                .to_owned(),
+            )
+            .exec(&self.context.db)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove_user_permission(&self, channel_id: Uuid, user_id: Uuid) -> AnyResult<()> {
+        channel_user_permission::Entity::delete_many()
+            .filter(channel_user_permission::Column::ChannelId.eq(channel_id))
+            .filter(channel_user_permission::Column::UserId.eq(user_id))
+            .exec(&self.context.db)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn get_role_permission(
+        &self,
+        channel_id: Uuid,
+        role_id: Uuid,
+    ) -> AnyResult<Option<channel_role_permission::Model>> {
+        Ok(channel_role_permission::Entity::find()
+            .filter(channel_role_permission::Column::ChannelId.eq(channel_id))
+            .filter(channel_role_permission::Column::RoleId.eq(role_id))
+            .one(&self.context.db)
+            .await?)
+    }
+
+    pub async fn set_role_permission(
+        &self,
+        channel_id: Uuid,
+        role_id: Uuid,
+        permissions: u64,
+    ) -> AnyResult<()> {
+        let permission = channel_role_permission::ActiveModel {
+            channel_id: Set(channel_id),
+            role_id: Set(role_id),
+            permissions: Set(permissions as i64),
+            ..Default::default()
+        };
+
+        channel_role_permission::Entity::insert(permission)
+            .on_conflict(
+                OnConflict::columns([
+                    channel_role_permission::Column::ChannelId,
+                    channel_role_permission::Column::RoleId,
+                ])
+                .update_columns([channel_role_permission::Column::Permissions])
+                .to_owned(),
+            )
+            .exec(&self.context.db)
+            .await?;
+
+        Ok(())
+    }
+
+    pub async fn remove_role_permission(&self, channel_id: Uuid, role_id: Uuid) -> AnyResult<()> {
+        channel_role_permission::Entity::delete_many()
+            .filter(channel_role_permission::Column::ChannelId.eq(channel_id))
+            .filter(channel_role_permission::Column::RoleId.eq(role_id))
+            .exec(&self.context.db)
+            .await?;
+
+        Ok(())
+    }
 }

src/repositories/server.rs

@@ -104,6 +104,18 @@ impl ServerRepository {
         Ok(res as usize)
     }
 
+    pub async fn get_user_permission(
+        &self,
+        server_id: Uuid,
+        user_id: Uuid,
+    ) -> AnyResult<Option<server_user_permission::Model>> {
+        Ok(server_user_permission::Entity::find()
+            .filter(server_user_permission::Column::ServerId.eq(server_id))
+            .filter(server_user_permission::Column::UserId.eq(user_id))
+            .one(&self.context.db)
+            .await?)
+    }
+
     pub async fn set_user_permission(
         &self,
         server_id: Uuid,
@@ -140,6 +152,18 @@ impl ServerRepository {
         Ok(())
     }
 
+    pub async fn get_role_permission(
+        &self,
+        server_id: Uuid,
+        role_id: Uuid,
+    ) -> AnyResult<Option<server_role_permission::Model>> {
+        Ok(server_role_permission::Entity::find()
+            .filter(server_role_permission::Column::ServerId.eq(server_id))
+            .filter(server_role_permission::Column::RoleId.eq(role_id))
+            .one(&self.context.db)
+            .await?)
+    }
+
     pub async fn set_role_permission(
         &self,
         server_id: Uuid,

src/routes/channel/dto.rs

@@ -35,3 +35,26 @@ pub struct ChannelResponse {
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
+
+#[derive(Debug, Serialize, Deserialize, ToSchema)]
+pub struct SetChannelPermissionRequest {
+    /// Bitmask des permissions à appliquer.
+    #[schema(example = 15)]
+    pub permissions: u64,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct ChannelUserPermissionResponse {
+    pub id: Uuid,
+    pub channel_id: Uuid,
+    pub user_id: Uuid,
+    pub permissions: u64,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct ChannelRolePermissionResponse {
+    pub id: Uuid,
+    pub channel_id: Uuid,
+    pub role_id: Uuid,
+    pub permissions: u64,
+}

src/routes/channel/handlers.rs

@@ -1,7 +1,10 @@
 use crate::core::state::AppState;
 use crate::http::context::Superuser;
 use crate::http::error::HTTPError;
-use crate::routes::channel::dto::{ChannelResponse, CreateChannelRequest, UpdateChannelRequest};
+use crate::routes::channel::dto::{
+    ChannelResponse, ChannelRolePermissionResponse, ChannelUserPermissionResponse,
+    CreateChannelRequest, SetChannelPermissionRequest, UpdateChannelRequest,
+};
 use crate::routes::channel::mapper;
 use axum::{
     extract::{Path, State},
@@ -195,3 +198,217 @@ pub async fn delete(
         Err(HTTPError::NotFound)
     }
 }
+
+/// Récupère les permissions directes d'un utilisateur dans un canal.
+#[utoipa::path(
+    get,
+    path = "/channels/{channel_id}/permissions/users/{user_id}",
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("user_id" = Uuid, Path, description = "ID de l'utilisateur")
+    ),
+    responses(
+        (status = 200, body = ChannelUserPermissionResponse),
+        (status = 404, description = "Permission introuvable"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Channel Permissions"
+)]
+pub async fn get_user_permission(
+    State(state): State<AppState>,
+    Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
+) -> Result<Json<ChannelUserPermissionResponse>, HTTPError> {
+    let permission = state
+        .repositories
+        .channel
+        .get_user_permission(channel_id, user_id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    Ok(Json(mapper::channel_user_permission_to_response(
+        permission,
+    )))
+}
+
+/// Définit ou remplace les permissions directes d'un utilisateur dans un canal.
+#[utoipa::path(
+    put,
+    path = "/channels/{channel_id}/permissions/users/{user_id}",
+    request_body = SetChannelPermissionRequest,
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("user_id" = Uuid, Path, description = "ID de l'utilisateur")
+    ),
+    responses(
+        (status = 200, body = ChannelUserPermissionResponse),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Channel Permissions"
+)]
+pub async fn set_user_permission(
+    State(state): State<AppState>,
+    Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
+    Json(payload): Json<SetChannelPermissionRequest>,
+) -> Result<Json<ChannelUserPermissionResponse>, HTTPError> {
+    state
+        .repositories
+        .channel
+        .set_user_permission(channel_id, user_id, payload.permissions)
+        .await?;
+
+    let permission = state
+        .repositories
+        .channel
+        .get_user_permission(channel_id, user_id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    Ok(Json(mapper::channel_user_permission_to_response(
+        permission,
+    )))
+}
+
+/// Supprime les permissions directes d'un utilisateur dans un canal.
+#[utoipa::path(
+    delete,
+    path = "/channels/{channel_id}/permissions/users/{user_id}",
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("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 = "Channel Permissions"
+)]
+pub async fn remove_user_permission(
+    State(state): State<AppState>,
+    Path((channel_id, user_id)): Path<(Uuid, Uuid)>,
+) -> Result<StatusCode, HTTPError> {
+    if state
+        .repositories
+        .channel
+        .get_user_permission(channel_id, user_id)
+        .await?
+        .is_none()
+    {
+        return Err(HTTPError::NotFound);
+    }
+
+    state
+        .repositories
+        .channel
+        .remove_user_permission(channel_id, user_id)
+        .await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}
+
+/// Récupère les permissions d'un rôle dans un canal.
+#[utoipa::path(
+    get,
+    path = "/channels/{channel_id}/permissions/roles/{role_id}",
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("role_id" = Uuid, Path, description = "ID du rôle")
+    ),
+    responses(
+        (status = 200, body = ChannelRolePermissionResponse),
+        (status = 404, description = "Permission introuvable"),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Channel Permissions"
+)]
+pub async fn get_role_permission(
+    State(state): State<AppState>,
+    Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
+) -> Result<Json<ChannelRolePermissionResponse>, HTTPError> {
+    let permission = state
+        .repositories
+        .channel
+        .get_role_permission(channel_id, role_id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    Ok(Json(mapper::channel_role_permission_to_response(
+        permission,
+    )))
+}
+
+/// Définit ou remplace les permissions d'un rôle dans un canal.
+#[utoipa::path(
+    put,
+    path = "/channels/{channel_id}/permissions/roles/{role_id}",
+    request_body = SetChannelPermissionRequest,
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("role_id" = Uuid, Path, description = "ID du rôle")
+    ),
+    responses(
+        (status = 200, body = ChannelRolePermissionResponse),
+        (status = 500, description = "Erreur interne du serveur")
+    ),
+    tag = "Channel Permissions"
+)]
+pub async fn set_role_permission(
+    State(state): State<AppState>,
+    Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
+    Json(payload): Json<SetChannelPermissionRequest>,
+) -> Result<Json<ChannelRolePermissionResponse>, HTTPError> {
+    state
+        .repositories
+        .channel
+        .set_role_permission(channel_id, role_id, payload.permissions)
+        .await?;
+
+    let permission = state
+        .repositories
+        .channel
+        .get_role_permission(channel_id, role_id)
+        .await?
+        .ok_or(HTTPError::NotFound)?;
+
+    Ok(Json(mapper::channel_role_permission_to_response(
+        permission,
+    )))
+}
+
+/// Supprime les permissions d'un rôle dans un canal.
+#[utoipa::path(
+    delete,
+    path = "/channels/{channel_id}/permissions/roles/{role_id}",
+    params(
+        ("channel_id" = Uuid, Path, description = "ID du canal"),
+        ("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 = "Channel Permissions"
+)]
+pub async fn remove_role_permission(
+    State(state): State<AppState>,
+    Path((channel_id, role_id)): Path<(Uuid, Uuid)>,
+) -> Result<StatusCode, HTTPError> {
+    if state
+        .repositories
+        .channel
+        .get_role_permission(channel_id, role_id)
+        .await?
+        .is_none()
+    {
+        return Err(HTTPError::NotFound);
+    }
+
+    state
+        .repositories
+        .channel
+        .remove_role_permission(channel_id, role_id)
+        .await?;
+
+    Ok(StatusCode::NO_CONTENT)
+}

src/routes/channel/mapper.rs

@@ -1,5 +1,8 @@
-use crate::models::channel;
+use crate::models::{channel, channel_role_permission, channel_user_permission};
-use crate::routes::channel::dto::{ChannelResponse, CreateChannelRequest, UpdateChannelRequest};
+use crate::routes::channel::dto::{
+    ChannelResponse, ChannelRolePermissionResponse, ChannelUserPermissionResponse,
+    CreateChannelRequest, UpdateChannelRequest,
+};
 use sea_orm::Set;
 use uuid::Uuid;
 
@@ -39,3 +42,25 @@ pub fn update_request_to_am(id: Uuid, req: UpdateChannelRequest) -> channel::Act
         ..Default::default()
     }
 }
+
+pub fn channel_user_permission_to_response(
+    model: channel_user_permission::Model,
+) -> ChannelUserPermissionResponse {
+    ChannelUserPermissionResponse {
+        id: model.id,
+        channel_id: model.channel_id,
+        user_id: model.user_id,
+        permissions: model.permissions as u64,
+    }
+}
+
+pub fn channel_role_permission_to_response(
+    model: channel_role_permission::Model,
+) -> ChannelRolePermissionResponse {
+    ChannelRolePermissionResponse {
+        id: model.id,
+        channel_id: model.channel_id,
+        role_id: model.role_id,
+        permissions: model.permissions as u64,
+    }
+}

src/routes/channel/routes.rs

@@ -11,4 +11,16 @@ pub fn router() -> Router<AppState> {
                 .put(handlers::update)
                 .delete(handlers::delete),
         )
+        .route(
+            "/channels/{channel_id}/permissions/users/{user_id}",
+            get(handlers::get_user_permission)
+                .put(handlers::set_user_permission)
+                .delete(handlers::remove_user_permission),
+        )
+        .route(
+            "/channels/{channel_id}/permissions/roles/{role_id}",
+            get(handlers::get_role_permission)
+                .put(handlers::set_role_permission)
+                .delete(handlers::remove_role_permission),
+        )
 }

src/routes/server/dto.rs

@@ -27,3 +27,26 @@ pub struct ServerResponse {
     pub created_at: DateTime<Utc>,
     pub updated_at: DateTime<Utc>,
 }
+
+#[derive(Debug, Serialize, Deserialize, ToSchema)]
+pub struct SetServerPermissionRequest {
+    /// Bitmask des permissions à appliquer.
+    #[schema(example = 7)]
+    pub permissions: u64,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct ServerUserPermissionResponse {
+    pub id: Uuid,
+    pub server_id: Uuid,
+    pub user_id: Uuid,
+    pub permissions: u64,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct ServerRolePermissionResponse {
+    pub id: Uuid,
+    pub server_id: Uuid,
+    pub role_id: Uuid,
+    pub permissions: u64,
+}

src/routes/server/handlers.rs

@@ -1,7 +1,10 @@
 use crate::core::state::AppState;
 use crate::http::context::Superuser;
 use crate::http::error::HTTPError;
-use crate::routes::server::dto::{CreateServerRequest, ServerResponse, UpdateServerRequest};
+use crate::routes::server::dto::{
+    CreateServerRequest, ServerResponse, ServerRolePermissionResponse,
+    ServerUserPermissionResponse, SetServerPermissionRequest, UpdateServerRequest,
+};
 use crate::routes::server::mapper;
 use axum::{
     extract::{Path, State},
@@ -153,3 +156,209 @@ pub async fn delete(
         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)))
+}
+
+/// 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(
+    State(state): State<AppState>,
+    Path((server_id, user_id)): Path<(Uuid, Uuid)>,
+    Json(payload): Json<SetServerPermissionRequest>,
+) -> Result<Json<ServerUserPermissionResponse>, HTTPError> {
+    state
+        .repositories
+        .server
+        .set_user_permission(server_id, user_id, payload.permissions)
+        .await?;
+
+    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(
+    State(state): State<AppState>,
+    Path((server_id, user_id)): Path<(Uuid, Uuid)>,
+) -> Result<StatusCode, HTTPError> {
+    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?;
+
+    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(
+    State(state): State<AppState>,
+    Path((server_id, role_id)): Path<(Uuid, Uuid)>,
+    Json(payload): Json<SetServerPermissionRequest>,
+) -> Result<Json<ServerRolePermissionResponse>, HTTPError> {
+    state
+        .repositories
+        .server
+        .set_role_permission(server_id, role_id, payload.permissions)
+        .await?;
+
+    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(
+    State(state): State<AppState>,
+    Path((server_id, role_id)): Path<(Uuid, Uuid)>,
+) -> Result<StatusCode, HTTPError> {
+    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?;
+
+    Ok(StatusCode::NO_CONTENT)
+}

src/routes/server/mapper.rs

@@ -1,5 +1,8 @@
-use crate::models::server;
+use crate::models::{server, server_role_permission, server_user_permission};
-use crate::routes::server::dto::{CreateServerRequest, ServerResponse, UpdateServerRequest};
+use crate::routes::server::dto::{
+    CreateServerRequest, ServerResponse, ServerRolePermissionResponse,
+    ServerUserPermissionResponse, UpdateServerRequest,
+};
 use sea_orm::Set;
 use uuid::Uuid;
 
@@ -32,3 +35,25 @@ pub fn update_request_to_am(id: Uuid, req: UpdateServerRequest) -> server::Activ
         ..Default::default()
     }
 }
+
+pub fn server_user_permission_to_response(
+    model: server_user_permission::Model,
+) -> ServerUserPermissionResponse {
+    ServerUserPermissionResponse {
+        id: model.id,
+        server_id: model.server_id,
+        user_id: model.user_id,
+        permissions: model.permissions as u64,
+    }
+}
+
+pub fn server_role_permission_to_response(
+    model: server_role_permission::Model,
+) -> ServerRolePermissionResponse {
+    ServerRolePermissionResponse {
+        id: model.id,
+        server_id: model.server_id,
+        role_id: model.role_id,
+        permissions: model.permissions as u64,
+    }
+}

src/routes/server/routes.rs

@@ -11,4 +11,16 @@ pub fn router() -> Router<AppState> {
                 .put(handlers::update)
                 .delete(handlers::delete),
         )
+        .route(
+            "/servers/{server_id}/permissions/users/{user_id}",
+            get(handlers::get_user_permission)
+                .put(handlers::set_user_permission)
+                .delete(handlers::remove_user_permission),
+        )
+        .route(
+            "/servers/{server_id}/permissions/roles/{role_id}",
+            get(handlers::get_role_permission)
+                .put(handlers::set_role_permission)
+                .delete(handlers::remove_role_permission),
+        )
 }