init

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,