init

2026-08-29 18:58:13 +02:00
parent 9551e90678
commit f2197a6b28
7 changed files with 214 additions and 73 deletions
@@ -1,7 +1,9 @@
 use crate::domain::events::channel::{ChannelCreatedEvent, ChannelDeletedEvent};
+use crate::domain::events::server_tree::ServerTreeInvalidatedEvent;
 use crate::models::server;
 use crate::repositories::Repositories;
 use crate::services::ServicesContext;
+use event_bus::EventBus;
 use std::sync::Arc;
 use uuid::Uuid;
 // list of all events :
@@ -57,6 +59,16 @@ pub struct PermissionSyncService {
 }

 impl PermissionSyncService {
+    fn invalidate_tree(event_bus: &Arc<EventBus>, server_id: Uuid, user_ids: Option<Vec<Uuid>>) {
+        event_bus.emit(
+            "server_tree_invalidated",
+            ServerTreeInvalidatedEvent {
+                server_id,
+                user_ids,
+            },
+        );
+    }
+
    pub fn new(service_context: Arc<ServicesContext>) -> Self {
        Self { service_context }
    }
@@ -70,6 +82,7 @@ impl PermissionSyncService {
        // ---------------------------------------------------------------------
        // Événements Serveur & Membres Serveur
        // ---------------------------------------------------------------------
+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "server_created",
            repositories.clone(),
@@ -81,16 +94,25 @@ impl PermissionSyncService {
        event_bus.on_async_with(
            "server_user_created",
            repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
            },
        );

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "server_user_deleted",
            repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
            },
        );

@@ -98,19 +120,29 @@ impl PermissionSyncService {
        // Événements Rôles & Membres de Rôle
        // ---------------------------------------------------------------------

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "role_user_created",
            repositories.clone(),
-            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
            },
        );

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "role_user_deleted",
            repositories.clone(),
-            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
            },
        );

@@ -118,19 +150,29 @@ impl PermissionSyncService {
        // Overrides de Permissions Serveur
        // ---------------------------------------------------------------------

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "server_role_permission_updated",
            repositories.clone(),
-            move |repositories, (role_id, server_id): (Uuid, Uuid)| async move {
-                Self::sync_role_members(repositories, role_id, server_id).await;
+            move |repositories, (role_id, server_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_role_members(repositories, role_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, None);
+                }
            },
        );

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "server_user_permission_updated",
            repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
            },
        );

@@ -138,73 +180,103 @@ impl PermissionSyncService {
        // Événements Canaux & Overrides de Permissions Canaux
        // ---------------------------------------------------------------------

+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "channel_created",
            repositories.clone(),
-            move |repositories, event: ChannelCreatedEvent| async move {
-                if let Some(server_id) = event.channel.server_id {
-                    Self::sync_server(repositories, server_id).await;
-                }
-            },
-        );
-
-        event_bus.on_async_with(
-            "channel_deleted",
-            repositories.clone(),
-            move |repositories, event: ChannelDeletedEvent| async move {
-                if let Some(server_id) = event.channel.server_id {
-                    Self::sync_server(repositories, server_id).await;
-                }
-            },
-        );
-
-        event_bus.on_async_with(
-            "channel_role_permission_updated",
-            repositories.clone(),
-            move |repositories, (role_id, server_id): (Uuid, Uuid)| async move {
-                Self::sync_role_members(repositories, role_id, server_id).await;
-            },
-        );
-
-        event_bus.on_async_with(
-            "channel_user_permission_updated",
-            repositories.clone(),
-            move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
-                Self::sync_user(repositories, user_id, server_id).await;
-            },
-        );
-
-        event_bus.on_async_with(
-            "channel_user_permission_created",
-            repositories.clone(),
-            move |repositories, (channel_id, user_id, _permissions): (Uuid, Uuid, u64)| async move {
-                if let Some(channel) = repositories
-                    .channel
-                    .get_by_id(channel_id)
-                    .await
-                    .ok()
-                    .flatten()
-                {
-                    if let Some(server_id) = channel.server_id {
-                        Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, event: ChannelCreatedEvent| {
+                let notify = notify.clone();
+                async move {
+                    if let Some(server_id) = event.channel.server_id {
+                        Self::sync_server(repositories, server_id).await;
+                        Self::invalidate_tree(&notify, server_id, None);
                    }
                }
            },
        );

+        let notify = event_bus.clone();
+        event_bus.on_async_with(
+            "channel_deleted",
+            repositories.clone(),
+            move |repositories, event: ChannelDeletedEvent| {
+                let notify = notify.clone();
+                async move {
+                    if let Some(server_id) = event.channel.server_id {
+                        Self::sync_server(repositories, server_id).await;
+                        Self::invalidate_tree(&notify, server_id, None);
+                    }
+                }
+            },
+        );
+
+        let notify = event_bus.clone();
+        event_bus.on_async_with(
+            "channel_role_permission_updated",
+            repositories.clone(),
+            move |repositories, (role_id, server_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_role_members(repositories, role_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, None);
+                }
+            },
+        );
+
+        let notify = event_bus.clone();
+        event_bus.on_async_with(
+            "channel_user_permission_updated",
+            repositories.clone(),
+            move |repositories, (server_id, user_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    Self::sync_user(repositories, user_id, server_id).await;
+                    Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                }
+            },
+        );
+
+        let notify = event_bus.clone();
+        event_bus.on_async_with(
+            "channel_user_permission_created",
+            repositories.clone(),
+            move |repositories, (channel_id, user_id, _permissions): (Uuid, Uuid, u64)| {
+                let notify = notify.clone();
+                async move {
+                    if let Some(channel) = repositories
+                        .channel
+                        .get_by_id(channel_id)
+                        .await
+                        .ok()
+                        .flatten()
+                    {
+                        if let Some(server_id) = channel.server_id {
+                            Self::sync_user(repositories, user_id, server_id).await;
+                            Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                        }
+                    }
+                }
+            },
+        );
+
+        let notify = event_bus.clone();
        event_bus.on_async_with(
            "channel_user_permission_deleted",
            repositories,
-            move |repositories, (channel_id, user_id): (Uuid, Uuid)| async move {
-                if let Some(channel) = repositories
-                    .channel
-                    .get_by_id(channel_id)
-                    .await
-                    .ok()
-                    .flatten()
-                {
-                    if let Some(server_id) = channel.server_id {
-                        Self::sync_user(repositories, user_id, server_id).await;
+            move |repositories, (channel_id, user_id): (Uuid, Uuid)| {
+                let notify = notify.clone();
+                async move {
+                    if let Some(channel) = repositories
+                        .channel
+                        .get_by_id(channel_id)
+                        .await
+                        .ok()
+                        .flatten()
+                    {
+                        if let Some(server_id) = channel.server_id {
+                            Self::sync_user(repositories, user_id, server_id).await;
+                            Self::invalidate_tree(&notify, server_id, Some(vec![user_id]));
+                        }
                    }
                }
            },