Init

src/hub/client.rs

@@ -20,7 +20,7 @@ pub struct Client {
 }
 
 impl Client {
-    pub fn new(
+    fn new(
         user_id: uuid::Uuid,
         connection_id: uuid::Uuid,
         app_state: AppState,
@@ -36,6 +36,26 @@ impl Client {
         }
     }
 
+    pub async fn connect(
+        user_id: uuid::Uuid,
+        connection_id: uuid::Uuid,
+        app_state: AppState,
+        sender: mpsc::Sender<Message>
+    ) -> Option<Self> {
+        // todo : vérifications ...
+        let client = Self::new(user_id, connection_id, app_state, sender);
+
+        Some(client)
+    }
+
+    pub async fn on_connect(&self) {
+        
+    }
+
+    pub async fn on_disconnect(&self) {
+        self.clear_tasks().await;
+    }
+
     pub async fn send(&self, message: Message) {
         let _ = self.sender.send(message).await;
     }
@@ -46,10 +66,6 @@ impl Client {
         }
     }
 
-    pub async fn on_disconnect(&self) {
-        self.clear_tasks().await;
-    }
-
     pub async fn add_task(&self, name: &str, task: JoinHandle<()>) {
         self.tasks.lock().insert(name.to_string(), task);
     }

src/network/http/web/ws_handler.rs

@@ -21,15 +21,14 @@ async fn ws_handler(
     ws: WebSocketUpgrade,
     State(app_state): State<AppState>
 ) -> impl IntoResponse {
-    // todo : récupérer le vrai id de l'utilisateur
+    // todo --- 1. VÉRIFICATION AVANT UPGRADE ---
-    println!("Nouvelle connexion WebSocket !");
+    // C'est ici qu'on vérifierait le JWT par exemple.
+    // Si ça échoue, on peut retourner une erreur HTTP direct.
     let user_id = Uuid::new_v4();
     ws.on_upgrade(move |socket| handle_socket(socket, user_id, app_state))
 }
 
 async fn handle_socket(socket: WebSocket, user_id: Uuid, app_state: AppState) {
-    println!("1Nouvelle session pour le client {}", user_id);
-    // .split() sépare la lecture de l'écriture
     let (mut ws_sender, mut ws_receiver) = socket.split();
     let (tx, mut rx) = mpsc::channel::<Message>(100);
 
@@ -37,11 +36,20 @@ async fn handle_socket(socket: WebSocket, user_id: Uuid, app_state: AppState) {
     let connection_id = Uuid::new_v4();
 
     // 1. Création de l'instance Client (ton objet intelligent)
-    let client = Client::new(user_id, connection_id, app_state.clone(), tx);
+    let client = match Client::connect(user_id, connection_id, app_state.clone(), tx).await {
+        Some(c) => c,
+        None => {
+            // Si refusé, on ferme la socket proprement
+            println!("Connexion refusée par le Hub pour {}", user_id);
+            return;
+        }
+    };
 
     // 2. Enregistrement dans le Hub global pour être visible des autres
     app_state.clients.add_client(client.clone());
 
+    client.on_connect().await;
+
     // 3. Tâche d'ENVOI : On écoute la boîte aux lettres et on pousse vers le navigateur
     let mut send_task = tokio::spawn(async move {
         while let Some(msg) = rx.recv().await {
@@ -63,8 +71,6 @@ async fn handle_socket(socket: WebSocket, user_id: Uuid, app_state: AppState) {
         }
     });
 
-    println!("2Nouvelle session pour le client {}", connection_id);
-
     // 5. Attente de la fin de session (Bloque ici jusqu'à la déco)
     tokio::select! {
         _ = (&mut send_task) => (),