init

src/core/mod.rs

@@ -1,12 +1,10 @@
-mod permission_sync;
 pub mod state;
 
 use crate::config::AppConfig;
-use crate::core::permission_sync::PermissionSyncService;
 use crate::core::state::Services;
 use crate::database::Database;
 use crate::http::server::HttpServer;
-use crate::metrics::{reporter, AppMetrics};
+use crate::metrics::{AppMetrics, reporter};
 use crate::repositories::Repositories;
 use crate::routes::gateway::GatewayManager;
 use crate::udp::server::UdpServer;
@@ -70,6 +68,8 @@ impl App {
 
         let metrics = AppMetrics::new();
 
+        let services = Arc::new(Services::new(repositories.clone(), event_bus.clone()));
+
         let permission_sync = PermissionSyncService::new(repositories.clone(), event_bus.clone());
 
         let state = AppState {

src/core/state.rs

@@ -1,9 +1,9 @@
 use crate::config::AppConfig;
-use crate::core::permission_sync::PermissionSyncService;
 use crate::metrics::AppMetrics;
 use crate::models::server;
 use crate::repositories::Repositories;
 use crate::routes::gateway::GatewayManager;
+use crate::services::Services;
 use event_bus::EventBus;
 use sea_orm::DatabaseConnection;
 use std::sync::{Arc, RwLock};
@@ -18,11 +18,7 @@ pub struct AppState {
     pub metrics: AppMetrics,
     pub gateway: Arc<GatewayManager>,
     pub event_bus: Arc<EventBus>,
+    pub services: Arc<Services>,
 }
 
 impl AppState {}
-
-#[derive(Debug, Clone)]
-pub struct Services {
-    pub permission_sync: Arc<PermissionSyncService>,
-}

src/lib.rs

@@ -14,4 +14,5 @@ pub mod metrics;
 
 pub mod domain;
 
+pub mod services;
 pub mod utils;

src/services/mod.rs

@@ -0,0 +1,40 @@
+use crate::repositories::Repositories;
+use crate::services::permission_sync::PermissionSyncService;
+use crate::services::server_order::ServerOrderService;
+use event_bus::EventBus;
+use std::sync::{Arc, OnceLock};
+
+pub mod permission_sync;
+mod server_order;
+
+#[derive(Debug, Clone)]
+pub struct ServicesContext {
+    pub repositories: Arc<Repositories>,
+    pub event_bus: Arc<EventBus>,
+    pub services: OnceLock<Services>,
+}
+
+#[derive(Debug, Clone)]
+pub struct Services {
+    permission_sync: Arc<PermissionSyncService>,
+    server_order: Arc<ServerOrderService>,
+}
+
+impl Services {
+    pub fn new(repositories: Arc<Repositories>, event_bus: Arc<EventBus>) -> Self {
+        let service_context = Arc::new(ServicesContext {
+            repositories,
+            event_bus,
+            services: OnceLock::new(),
+        });
+        let permission_sync = Arc::new(PermissionSyncService::new(service_context.clone()));
+        let server_order = Arc::new(ServerOrderService::new(service_context.clone()));
+
+        let services = Self {
+            permission_sync,
+            server_order,
+        };
+        let _ = service_context.services.set(services.clone());
+        services
+    }
+}

src/services/permission_sync.rs

@@ -1,5 +1,5 @@
 use crate::repositories::Repositories;
-use event_bus::EventBus;
+use crate::services::ServicesContext;
 use std::sync::Arc;
 use uuid::Uuid;
 // list of all events :
@@ -51,44 +51,42 @@ use uuid::Uuid;
 
 #[derive(Debug, Clone)]
 pub struct PermissionSyncService {
-    repositories: Arc<Repositories>,
+    service_context: Arc<ServicesContext>,
-    event_bus: Arc<EventBus>,
 }
 
 impl PermissionSyncService {
-    pub fn new(repositories: Arc<Repositories>, event_bus: Arc<EventBus>) -> Self {
+    pub fn new(service_context: Arc<ServicesContext>) -> Self {
-        Self {
+        Self { service_context }
-            repositories,
-            event_bus,
-        }
     }
 
     /// Enregistre les listeners sur l'EventBus pour mettre à jour le cache
     /// des permissions calculées lors des modifications de structure ou de droits.
     pub async fn start_listen_event(&self) {
+        let event_bus = self.service_context.event_bus.clone();
+        let repositories = self.service_context.repositories.clone();
+
         // ---------------------------------------------------------------------
         // Événements Serveur & Membres Serveur
         // ---------------------------------------------------------------------
-
+        event_bus.on_async_with(
-        self.event_bus.on_async_with(
             "server_created",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, server_id: Uuid| async move {
                 Self::sync_server(repositories, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "server_user_created",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "server_user_deleted",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },
@@ -98,17 +96,17 @@ impl PermissionSyncService {
         // Événements Rôles & Membres de Rôle
         // ---------------------------------------------------------------------
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "role_user_created",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "role_user_deleted",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (_role_id, user_id, server_id): (Uuid, Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },
@@ -118,17 +116,17 @@ impl PermissionSyncService {
         // Overrides de Permissions Serveur
         // ---------------------------------------------------------------------
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "server_role_permission_updated",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (role_id, server_id): (Uuid, Uuid)| async move {
                 Self::sync_role_members(repositories, role_id, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "server_user_permission_updated",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },
@@ -138,33 +136,33 @@ impl PermissionSyncService {
         // Événements Canaux & Overrides de Permissions Canaux
         // ---------------------------------------------------------------------
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "channel_created",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, server_id: Uuid| async move {
                 Self::sync_server(repositories, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "channel_deleted",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, server_id: Uuid| async move {
                 Self::sync_server(repositories, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "channel_role_permission_updated",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (role_id, server_id): (Uuid, Uuid)| async move {
                 Self::sync_role_members(repositories, role_id, server_id).await;
             },
         );
 
-        self.event_bus.on_async_with(
+        event_bus.on_async_with(
             "channel_user_permission_updated",
-            self.repositories.clone(),
+            repositories.clone(),
             move |repositories, (server_id, user_id): (Uuid, Uuid)| async move {
                 Self::sync_user(repositories, user_id, server_id).await;
             },

src/services/server_order.rs

@@ -0,0 +1,19 @@
+use crate::services::ServicesContext;
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub struct ServerOrderService {
+    service_context: Arc<ServicesContext>,
+}
+
+impl ServerOrderService {
+    pub fn new(service_context: Arc<ServicesContext>) -> Self {
+        Self { service_context }
+    }
+
+    pub async fn exemple_call_other_service(&self) {
+        if let Some(services) = self.service_context.services.get() {
+            services.permission_sync.start_listen_event().await;
+        }
+    }
+}