init

src/repositories/computed_permission.rs

@@ -1,8 +1,13 @@
-use crate::models::{computed_permission, group, group_member, server, user};
+use crate::models::{
+    category, channel, computed_permission, group, group_member, group_permission, server, user,
+    user_permission,
+};
 use crate::repositories::{AnyResult, RepositoryContext};
 // use sea_orm::prelude::*;
 use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
+use std::collections::HashMap;
 
+use crate::permissions::ServerPermission;
 use std::sync::Arc;
 use uuid::Uuid;
 
@@ -46,6 +51,86 @@ impl ComputedPermissionRepository {
             .filter(group_member::Column::UserId.eq(user_id))
             .all(&self.context.db)
             .await?;
+
+        // Récupération de toutes les catégories du serveur
+        let categories = category::Entity::find()
+            .filter(category::Column::ServerId.eq(server_id))
+            .all(&self.context.db)
+            .await?;
+
+        // Récupération de toutes les channels du serveur
+        let channels = channel::Entity::find()
+            .filter(channel::Column::ServerId.eq(server_id))
+            .all(&self.context.db)
+            .await?;
+
+        // retrieve permissions
+        let user_permissions = user_permission::Entity::find()
+            .filter(user_permission::Column::UserId.eq(user_id))
+            .filter(user_permission::Column::ServerId.eq(server_id))
+            .all(&self.context.db)
+            .await?;
+
+        let group_permissions = group_permission::Entity::find()
+            .filter(group_permission::Column::ServerId.eq(server_id))
+            .filter(group_member::Column::UserId.eq(user_id))
+            .all(&self.context.db)
+            .await?;
+
+        // computed existing permissions
+        struct VirtualComputedPermission {
+            server_permissions: i64,
+            channel_permissions: i64,
+            voice_permissions: i64,
+        }
+        let mut all_permissions: HashMap<Uuid, Vec<VirtualComputedPermission>> = HashMap::new();
+
+        user_permissions.into_iter().for_each(|user_permission| {
+            let permission = VirtualComputedPermission {
+                server_permissions: user_permission.server_permissions,
+                channel_permissions: user_permission.channel_permissions,
+                voice_permissions: user_permission.voice_permissions,
+            };
+
+            all_permissions
+                .entry(user_permission.scope_id) // vérifier que la clé existe dans la HashMap
+                .or_default() // appel Vec::new() automatiquement
+                .push(permission); // insert la permission dans le Vec
+        });
+
+        group_permissions.into_iter().for_each(|group_permission| {
+            let permission = VirtualComputedPermission {
+                server_permissions: group_permission.server_permissions,
+                channel_permissions: group_permission.channel_permissions,
+                voice_permissions: group_permission.voice_permissions,
+            };
+
+            all_permissions
+                .entry(group_permission.scope_id)
+                .or_default()
+                .push(permission);
+        });
+
+        // Compute permissions
+        // server
+        match all_permissions.get(&server_id) {
+            Some(perm) => {
+                let mut server_permissions = ServerPermission::empty();
+                for permission in perm {
+                    let current =
+                        ServerPermission::from_bits_retain(permission.server_permissions as u64);
+
+                    server_permissions |= current;
+                }
+            }
+            None => {}
+        }
+
+        // Category
+        // todo : à faire
+
+        // channels
+
         Ok(())
     }
 }