init

src/routes/category/mapper.rs

@@ -1,17 +1,25 @@
-use crate::models::category;
 use crate::domain::dto::category::{
     CategoryResponse, CreateCategoryRequest, UpdateCategoryRequest,
 };
+use crate::models::category;
 use sea_orm::Set;
 use uuid::Uuid;
 
 pub fn category_model_to_category_response(model: category::Model) -> CategoryResponse {
+    category_model_to_category_response_with_permission(model, None)
+}
+
+pub fn category_model_to_category_response_with_permission(
+    model: category::Model,
+    permission: Option<u64>,
+) -> CategoryResponse {
     CategoryResponse {
         id: model.id,
         server_id: model.server_id,
         name: model.name,
         created_at: model.created_at,
         updated_at: model.updated_at,
+        permission,
     }
 }
 

src/routes/channel/mapper.rs

@@ -1,13 +1,20 @@
-use crate::models::{channel, channel_role_permission, channel_user_permission};
-use crate::repositories::types::ChannelFilter;
 use crate::domain::dto::channel::{
     ChannelQueryParams, ChannelResponse, ChannelRolePermissionResponse,
     ChannelUserPermissionResponse, CreateChannelRequest, UpdateChannelRequest,
 };
+use crate::models::{channel, channel_role_permission, channel_user_permission};
+use crate::repositories::types::ChannelFilter;
 use sea_orm::Set;
 use uuid::Uuid;
 
 pub fn channel_model_to_channel_response(model: channel::Model) -> ChannelResponse {
+    channel_model_to_channel_response_with_permission(model, None)
+}
+
+pub fn channel_model_to_channel_response_with_permission(
+    model: channel::Model,
+    permission: Option<u64>,
+) -> ChannelResponse {
     ChannelResponse {
         id: model.id,
         server_id: model.server_id,
@@ -16,6 +23,7 @@ pub fn channel_model_to_channel_response(model: channel::Model) -> ChannelRespon
         name: model.name,
         created_at: model.created_at,
         updated_at: model.updated_at,
+        permission,
     }
 }
 

src/routes/server/handlers.rs

@@ -3,9 +3,8 @@ use crate::domain::dto::server::{
     CreateServerRequest, ServerResponse, ServerRolePermissionResponse, ServerTreeResponse,
     ServerUserPermissionResponse, SetServerPermissionRequest, UpdateServerRequest,
 };
-use crate::http::context::Superuser;
+use crate::http::context::{CurrentUser, Superuser};
 use crate::http::error::HTTPError;
-use crate::repositories::types::ChannelFilter;
 use crate::routes::server::mapper;
 use axum::{
     Json,
@@ -384,6 +383,7 @@ pub async fn remove_role_permission(
     tag = "Servers"
 )]
 pub async fn get_tree(
+    user: CurrentUser,
     State(state): State<AppState>,
     Path(server_id): Path<Uuid>,
 ) -> Result<Json<ServerTreeResponse>, HTTPError> {
@@ -395,20 +395,15 @@ pub async fn get_tree(
         .await?
         .ok_or(HTTPError::NotFound)?;
 
-    // Exécution parallèle des 3 requêtes via leurs repositories respectifs
-    let (orders, channels, categories) = tokio::try_join!(
-        state
-            .repositories
-            .server_item_order
-            .get_by_server(server_id),
-        state.repositories.channel.filter(ChannelFilter {
-            server_id: Some(server_id)
-        }),
-        state.repositories.category.get_by_server(server_id),
-    )?;
+    let tree = state
+        .repositories
+        .server_tree
+        .get_for_user(server_id, user.id)
+        .await?;
 
-    // Assemblage du ServerTreeResponse via le mapper
-    let tree = mapper::build_server_tree(orders, channels, categories);
-
-    Ok(Json(tree))
+    Ok(Json(mapper::build_server_tree(
+        tree.orders,
+        tree.channels,
+        tree.categories,
+    )))
 }

src/routes/server/mapper.rs

@@ -2,11 +2,10 @@ use crate::domain::dto::server::{
     CreateServerRequest, ServerExplorerItemResponse, ServerResponse, ServerRolePermissionResponse,
     ServerTreeResponse, ServerUserPermissionResponse, UpdateServerRequest,
 };
-use crate::models::{
-    category, channel, server, server_item_order, server_role_permission, server_user_permission,
-};
-use crate::routes::category::mapper::category_model_to_category_response;
-use crate::routes::channel::mapper::channel_model_to_channel_response;
+use crate::models::{server, server_item_order, server_role_permission, server_user_permission};
+use crate::repositories::types::{CategoryWithPermissions, ChannelWithPermissions};
+use crate::routes::category::mapper::category_model_to_category_response_with_permission;
+use crate::routes::channel::mapper::channel_model_to_channel_response_with_permission;
 use sea_orm::Set;
 use std::collections::HashMap;
 use uuid::Uuid;
@@ -65,44 +64,53 @@ pub fn server_role_permission_to_response(
 
 pub fn build_server_tree(
     orders: Vec<server_item_order::Model>,
-    channels: Vec<channel::Model>,
-    categories: Vec<category::Model>,
+    channels: Vec<ChannelWithPermissions>,
+    categories: Vec<CategoryWithPermissions>,
 ) -> ServerTreeResponse {
-    // Map d'accès rapide : resource_id -> order_key
     let order_map: HashMap<Uuid, i64> = orders
         .into_iter()
-        .map(|o| (o.resource_id, o.order_key))
+        .map(|order| (order.resource_id, order.order_key))
         .collect();
 
-    // Regrouper les canaux par catégorie ou orphelins
-    let mut category_channels: HashMap<Uuid, Vec<channel::Model>> = HashMap::new();
-    let mut orphan_channels: Vec<channel::Model> = Vec::new();
+    let mut category_channels: HashMap<Uuid, Vec<ChannelWithPermissions>> = HashMap::new();
+    let mut orphan_channels: Vec<ChannelWithPermissions> = Vec::new();
 
-    for chan in channels {
-        if let Some(cat_id) = chan.category_id {
-            category_channels.entry(cat_id).or_default().push(chan);
+    for channel_with_permissions in channels {
+        if let Some(category_id) = channel_with_permissions.channel.category_id {
+            category_channels
+                .entry(category_id)
+                .or_default()
+                .push(channel_with_permissions);
         } else {
-            orphan_channels.push(chan);
+            orphan_channels.push(channel_with_permissions);
         }
     }
 
     // Trier les canaux dans chaque catégorie par leur order_key
     for chans in category_channels.values_mut() {
-        chans.sort_by_key(|c| order_map.get(&c.id).copied().unwrap_or(i64::MAX));
+        chans.sort_by_key(|c| order_map.get(&c.channel.id).copied().unwrap_or(i64::MAX));
     }
 
     // Préparer les éléments racine (catégories & canaux orphelins) avec leur order_key
     let mut root_items: Vec<(ServerExplorerItemResponse, i64)> = Vec::new();
 
-    for cat in categories {
-        let cat_id = cat.id;
+    for cat_with_perm in categories {
+        let cat_id = cat_with_perm.category.id;
         let order_key = order_map.get(&cat_id).copied().unwrap_or(i64::MAX);
         let chans = category_channels.remove(&cat_id).unwrap_or_default();
 
-        let cat_response = category_model_to_category_response(cat);
+        let cat_perm_bits = cat_with_perm.permissions.map(|p| p.bits()).unwrap_or(0);
+        let cat_response = category_model_to_category_response_with_permission(
+            cat_with_perm.category,
+            Some(cat_perm_bits),
+        );
+
         let chan_responses = chans
             .into_iter()
-            .map(channel_model_to_channel_response)
+            .map(|c| {
+                let chan_perm_bits = c.permissions.map(|p| p.bits()).unwrap_or(0);
+                channel_model_to_channel_response_with_permission(c.channel, Some(chan_perm_bits))
+            })
             .collect();
 
         root_items.push((
@@ -111,9 +119,16 @@ pub fn build_server_tree(
         ));
     }
 
-    for chan in orphan_channels {
-        let order_key = order_map.get(&chan.id).copied().unwrap_or(i64::MAX);
-        let chan_response = channel_model_to_channel_response(chan);
+    for chan_with_perm in orphan_channels {
+        let order_key = order_map
+            .get(&chan_with_perm.channel.id)
+            .copied()
+            .unwrap_or(i64::MAX);
+        let chan_perm_bits = chan_with_perm.permissions.map(|p| p.bits()).unwrap_or(0);
+        let chan_response = channel_model_to_channel_response_with_permission(
+            chan_with_perm.channel,
+            Some(chan_perm_bits),
+        );
         root_items.push((
             ServerExplorerItemResponse::Channel(chan_response),
             order_key,