init

src/repositories/computed_permission.rs

@@ -5,17 +5,21 @@ use crate::models::{
 use crate::permissions::{ChannelPermission, ServerPermission};
 use crate::repositories::{AnyResult, RepositoryContext};
 
-use sea_orm::{ColumnTrait, EntityTrait, QueryFilter, QuerySelect, Set, TransactionTrait};
+use sea_orm::{
+    ColumnTrait, EntityTrait, PaginatorTrait, QueryFilter, QuerySelect, Set, TransactionTrait,
+};
 use std::collections::HashMap;
 use std::sync::{Arc, OnceLock};
-use tokio::sync::Mutex;
 use uuid::Uuid;
 
 use crate::models::computed_permission::PermissionScopeType;
+use crate::utils::ScopedLockManager;
 
-static SYNC_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-fn _sync_lock() -> &'static Mutex<()> {
-    SYNC_LOCK.get_or_init(Mutex::default)
+// Instance globale du manager de verrous scopés par Server ID
+static PERM_LOCK_MANAGER: OnceLock<ScopedLockManager<Uuid>> = OnceLock::new();
+
+fn lock_manager() -> &'static ScopedLockManager<Uuid> {
+    PERM_LOCK_MANAGER.get_or_init(ScopedLockManager::new)
 }
 
 #[derive(Clone, Debug)]
@@ -24,13 +28,29 @@ pub struct ComputedPermissionRepository {
 }
 
 impl ComputedPermissionRepository {
+    /// Récupère toutes les permissions calculées.
     pub async fn get_all(&self) -> AnyResult<Vec<computed_permission::Model>> {
         Ok(computed_permission::Entity::find()
             .all(&self.context.db)
             .await?)
     }
 
-    /// Recalcule le cache de permissions pour tous les utilisateurs du serveur.
+    /// Vérifie si l'utilisateur possède au moins une entrée de permission sur une ressource.
+    pub async fn had_perm_on(&self, user_id: Uuid, resource_id: Uuid) -> AnyResult<bool> {
+        Ok(computed_permission::Entity::find()
+            .filter(computed_permission::Column::UserId.eq(user_id))
+            .filter(computed_permission::Column::ResourceId.eq(resource_id))
+            .count(&self.context.db)
+            .await?
+            > 0)
+    }
+
+    // -------------------------------------------------------------------------
+    // Synchronisations de permissions scopées
+    // -------------------------------------------------------------------------
+
+    /// Scope SERVEUR : Recalcule le cache de permissions pour TOUS les utilisateurs du serveur.
+    /// À n'utiliser que pour les opérations lourdes ou structurelles.
     pub async fn full_sync_server(&self, server_id: Uuid) -> AnyResult<()> {
         let user_ids = server_user::Entity::find()
             .filter(server_user::Column::ServerId.eq(server_id))
@@ -47,20 +67,36 @@ impl ComputedPermissionRepository {
         Ok(())
     }
 
-    /// Recalcule le cache de permissions d'un utilisateur sur un serveur.
+    /// Scope RÔLE : Recalcule le cache uniquement pour les membres d'un rôle spécifique.
+    pub async fn sync_role_members(&self, role_id: Uuid, server_id: Uuid) -> AnyResult<()> {
+        let user_ids = role_user::Entity::find()
+            .filter(role_user::Column::RoleId.eq(role_id))
+            .select_only()
+            .column(role_user::Column::UserId)
+            .into_tuple::<Uuid>()
+            .all(&self.context.db)
+            .await?;
+
+        for user_id in user_ids {
+            self.full_sync_user(user_id, server_id).await?;
+        }
+
+        Ok(())
+    }
+
+    /// Scope UTILISATEUR : Recalcule le cache de permissions d'un seul utilisateur sur un serveur.
     ///
     /// Les permissions effectives sont composées de :
-    ///
     /// - permissions serveur accordées aux rôles de l'utilisateur ;
     /// - permissions serveur accordées directement à l'utilisateur ;
     /// - permissions de canal accordées aux rôles de l'utilisateur ;
     /// - permissions directes de l'utilisateur dans les canaux.
     pub async fn full_sync_user(&self, user_id: Uuid, server_id: Uuid) -> AnyResult<()> {
-        let _guard = _sync_lock().lock().await;
-        // ---------------------------------------------------------------------
-        // Rôles de l'utilisateur
-        // ---------------------------------------------------------------------
+        let _server_guard = lock_manager().lock_scope(server_id).await;
 
+        // ---------------------------------------------------------------------
+        // 1. Rôles de l'utilisateur
+        // ---------------------------------------------------------------------
         let role_ids = role_user::Entity::find()
             .filter(role_user::Column::UserId.eq(user_id))
             .select_only()
@@ -70,9 +106,8 @@ impl ComputedPermissionRepository {
             .await?;
 
         // ---------------------------------------------------------------------
-        // Permissions serveur des rôles
+        // 2. Permissions serveur des rôles
         // ---------------------------------------------------------------------
-
         let mut server_permissions = ServerPermission::empty();
 
         if !role_ids.is_empty() {
@@ -89,9 +124,8 @@ impl ComputedPermissionRepository {
         }
 
         // ---------------------------------------------------------------------
-        // Permissions serveur directes de l'utilisateur
+        // 3. Permissions serveur directes de l'utilisateur
         // ---------------------------------------------------------------------
-
         if let Some(permission) = server_user_permission::Entity::find()
             .filter(server_user_permission::Column::ServerId.eq(server_id))
             .filter(server_user_permission::Column::UserId.eq(user_id))
@@ -102,20 +136,18 @@ impl ComputedPermissionRepository {
         }
 
         // ---------------------------------------------------------------------
-        // Canaux du serveur
+        // 4. Canaux du serveur
         // ---------------------------------------------------------------------
-
         let channels = channel::Entity::find()
             .filter(channel::Column::ServerId.eq(server_id))
             .all(&self.context.db)
             .await?;
 
-        let channel_ids: Vec<Uuid> = channels.iter().map(|channel| channel.id).collect();
+        let channel_ids: Vec<Uuid> = channels.iter().map(|c| c.id).collect();
 
         // ---------------------------------------------------------------------
-        // Permissions de rôles pour tous les canaux
+        // 5. Permissions de rôles pour tous les canaux
         // ---------------------------------------------------------------------
-
         let role_channel_permissions = if role_ids.is_empty() || channel_ids.is_empty() {
             Vec::new()
         } else {
@@ -138,9 +170,8 @@ impl ComputedPermissionRepository {
         }
 
         // ---------------------------------------------------------------------
-        // Permissions directes de l'utilisateur pour tous les canaux
+        // 6. Permissions directes de l'utilisateur pour tous les canaux
         // ---------------------------------------------------------------------
-
         let user_channel_permissions = if channel_ids.is_empty() {
             Vec::new()
         } else {
@@ -161,12 +192,11 @@ impl ComputedPermissionRepository {
         }
 
         // ---------------------------------------------------------------------
-        // Construction du cache
+        // 7. Construction des modèles à insérer
         // ---------------------------------------------------------------------
-
         let mut computed_permissions = Vec::with_capacity(channels.len().saturating_add(1));
 
-        // Permissions au niveau serveur.
+        // Permissions au niveau serveur
         computed_permissions.push(computed_permission::ActiveModel {
             user_id: Set(user_id),
             server_id: Set(server_id),
@@ -176,7 +206,7 @@ impl ComputedPermissionRepository {
             ..Default::default()
         });
 
-        // Permissions au niveau canal.
+        // Permissions au niveau canal
         for channel in channels {
             let channel_permissions = permissions_by_channel
                 .remove(&channel.id)
@@ -193,9 +223,8 @@ impl ComputedPermissionRepository {
         }
 
         // ---------------------------------------------------------------------
-        // Remplacement atomique du cache
+        // 8. Remplacement atomique du cache en BDD
         // ---------------------------------------------------------------------
-
         self.context
             .db
             .transaction::<_, (), anyhow::Error>(|transaction| {