diff --git a/migration/src/m20220101_000001_create_table.rs b/migration/src/m20220101_000001_create_table.rs index a489339..135e606 100644 --- a/migration/src/m20220101_000001_create_table.rs +++ b/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( diff --git a/src/repositories/channel.rs b/src/repositories/channel.rs index 33c89e7..c3917e6 100644 --- a/src/repositories/channel.rs +++ b/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> { + pub async fn get_by_id(&self, id: Uuid) -> AnyResult> { 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 { + pub async fn delete(&self, id: Uuid) -> AnyResult { 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> { + 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> { + 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(()) + } } diff --git a/src/repositories/server.rs b/src/repositories/server.rs index 705e7a5..bdd941f 100644 --- a/src/repositories/server.rs +++ b/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> { + 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> { + 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, diff --git a/src/routes/channel/dto.rs b/src/routes/channel/dto.rs index 90a656b..187ffef 100644 --- a/src/routes/channel/dto.rs +++ b/src/routes/channel/dto.rs @@ -35,3 +35,26 @@ pub struct ChannelResponse { pub created_at: DateTime, pub updated_at: DateTime, } + +#[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, +} diff --git a/src/routes/channel/handlers.rs b/src/routes/channel/handlers.rs index 59ccda5..2387ca2 100644 --- a/src/routes/channel/handlers.rs +++ b/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, + Path((channel_id, user_id)): Path<(Uuid, Uuid)>, +) -> Result, 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, + Path((channel_id, user_id)): Path<(Uuid, Uuid)>, + Json(payload): Json, +) -> Result, 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, + Path((channel_id, user_id)): Path<(Uuid, Uuid)>, +) -> Result { + 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, + Path((channel_id, role_id)): Path<(Uuid, Uuid)>, +) -> Result, 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, + Path((channel_id, role_id)): Path<(Uuid, Uuid)>, + Json(payload): Json, +) -> Result, 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, + Path((channel_id, role_id)): Path<(Uuid, Uuid)>, +) -> Result { + 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) +} diff --git a/src/routes/channel/mapper.rs b/src/routes/channel/mapper.rs index b5cf4bb..0a7f432 100644 --- a/src/routes/channel/mapper.rs +++ b/src/routes/channel/mapper.rs @@ -1,5 +1,8 @@ -use crate::models::channel; -use crate::routes::channel::dto::{ChannelResponse, CreateChannelRequest, UpdateChannelRequest}; +use crate::models::{channel, channel_role_permission, channel_user_permission}; +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, + } +} diff --git a/src/routes/channel/routes.rs b/src/routes/channel/routes.rs index 0455d0d..5ad54ce 100644 --- a/src/routes/channel/routes.rs +++ b/src/routes/channel/routes.rs @@ -11,4 +11,16 @@ pub fn router() -> Router { .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), + ) } diff --git a/src/routes/server/dto.rs b/src/routes/server/dto.rs index 2e08471..6deca55 100644 --- a/src/routes/server/dto.rs +++ b/src/routes/server/dto.rs @@ -27,3 +27,26 @@ pub struct ServerResponse { pub created_at: DateTime, pub updated_at: DateTime, } + +#[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, +} diff --git a/src/routes/server/handlers.rs b/src/routes/server/handlers.rs index 3e33c02..185f588 100644 --- a/src/routes/server/handlers.rs +++ b/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, + Path((server_id, user_id)): Path<(Uuid, Uuid)>, +) -> Result, 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, + Path((server_id, user_id)): Path<(Uuid, Uuid)>, + Json(payload): Json, +) -> Result, 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, + Path((server_id, user_id)): Path<(Uuid, Uuid)>, +) -> Result { + 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, + Path((server_id, role_id)): Path<(Uuid, Uuid)>, +) -> Result, 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, + Path((server_id, role_id)): Path<(Uuid, Uuid)>, + Json(payload): Json, +) -> Result, 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, + Path((server_id, role_id)): Path<(Uuid, Uuid)>, +) -> Result { + 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) +} diff --git a/src/routes/server/mapper.rs b/src/routes/server/mapper.rs index 04e947e..b5c33a6 100644 --- a/src/routes/server/mapper.rs +++ b/src/routes/server/mapper.rs @@ -1,5 +1,8 @@ -use crate::models::server; -use crate::routes::server::dto::{CreateServerRequest, ServerResponse, UpdateServerRequest}; +use crate::models::{server, server_role_permission, server_user_permission}; +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, + } +} diff --git a/src/routes/server/routes.rs b/src/routes/server/routes.rs index 6ddd70c..ce79e6b 100644 --- a/src/routes/server/routes.rs +++ b/src/routes/server/routes.rs @@ -11,4 +11,16 @@ pub fn router() -> Router { .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), + ) }