server from db working

src/minecraft/client/client.rs

@@ -6,7 +6,7 @@
 /*   By: tomoron <tomoron@student.42angouleme.fr>   +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2026/05/07 17:23:09 by tomoron           #+#    #+#             */
-/*   Updated: 2026/05/30 00:27:19 by tomoron          ###   ########.fr       */
+/*   Updated: 2026/05/31 23:23:05 by tomoron          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,6 +15,8 @@ use crate::minecraft::handshake::Handshake;
 use crate::minecraft::varint::varint_write;
 use std::fmt;
 
+use crate::models::Servers;
+
 pub struct Client {
     pub in_stream: TcpStream,
 
@@ -22,11 +24,22 @@ pub struct Client {
     pub buffer: Vec<u8>,
     pub out_stream: Option<TcpStream>,
     pub handshake: Option<Handshake>,
+
+    pub closed: bool,
+
+    pub server: Option<Result<Servers,diesel::result::Error>>,
+
     pub dbPool: DbPool
 }
 
 use crate::DbPool;
 
+use crate::schema;
+use crate::models;
+use diesel::prelude::*;
+
+use regex::Regex;
+
 impl Client {
     pub fn create(stream: TcpStream, pool: DbPool) -> Self {
         Self {
@@ -37,20 +50,40 @@ impl Client {
             out_stream: None,
             handshake: None,
 
+            closed: false,
+
+            server: None,
+
             dbPool: pool
         }
     }
 
 
-    pub async fn send_packet(&self, data: Vec<u8>) {
-        let mut sent_data: Vec<u8> = varint_write(data.len() as i32);
-
-        sent_data.extend(data);
-        let _ = self.in_stream.writable().await;
-        match self.in_stream.try_write(sent_data.as_slice()) {
-            Err(e) => { eprintln!("error while sending response {:?}", e); },
-            _ => { }
+    pub async fn get_server(&self) -> Result<Servers, diesel::result::Error> {
+        println!("get server name from domain : {}", self.handshake.as_ref().unwrap().server_address);
+        if let None = self.handshake {
+            panic!("get server called without a handshake");
         }
+
+
+        let conn = &mut self.dbPool.get().unwrap();
+
+        let reg = Regex::new(r"^(?:([a-zA-Z-_]*)\.)?mc\.tmoron\.fr$").unwrap();
+        let mut found: Option<String> = None;
+        if let Some(capture) = reg.captures(&self.handshake.as_ref().unwrap().server_address) {
+            if let Some(captured_str) = capture.get(1) {
+                found = Some(captured_str.as_str().to_string());
+            }
+        }
+
+        if let Some(name) = found {
+            println!("found server name : {}", name);
+            schema::servers::table.filter(schema::servers::name.eq(name)).select(models::Servers::as_select()).first(conn)
+        } else {
+            schema::servers::table.filter(schema::servers::is_default.eq(true)).select(models::Servers::as_select()).first(conn)
+
+        }
+
     }
 
 }