some fixes, first push to ovh, discord webhook

src/chat/handlers.rs

@@ -1,16 +1,18 @@
 
+use std::collections::HashMap;
+
 use axum::{
-    extract::{
+    Json, extract::{
         FromRequest,FromRequestParts, State,
     
-    }, http::StatusCode, response::{sse::KeepAlive, IntoResponse},
+    }, http::StatusCode, response::{IntoResponse, sse::KeepAlive}
     
 };
 //use axum::extract::ws::Message;
 use chrono::NaiveDateTime;
-use rusqlite::params;
+use rusqlite::{Name, params};
 use serde::Serialize;
-use serde_json::json;
+use serde_json::{json, to_value};
 
 use crate::chat::extractor::{
 AddUserConversationPayload, CreateConversationPayload, GetMessagesPayload, SendMessagePayload
@@ -154,6 +156,7 @@ pub async fn send_message(
 
             if let Some(hotel_users) = state.ws_map.get(&hotel_id) {
                 let update_msg = serde_json::json!({
+                    "event-type": "chat-message",
                     "conv_id": payload.conv_id,
                     "sender": user_id,
                     "content": payload.message,
@@ -280,3 +283,140 @@ pub async fn get_hotel_users(
     }
 }
 
+#[derive(Debug, Serialize)]
+struct Conversation {
+    id: i32,
+    title: String,
+}
+
+pub async fn get_convs(
+    State(state): State<AppState>,
+    //Path((item_name, item_amount)): Path<(String, i32)>,
+    AuthClaims{ user_id, hotel_id}: AuthClaims,
+) -> impl IntoResponse {
+
+    let pool = state.hotel_pools.get_pool(hotel_id);
+
+    let conn = match pool.get(){
+        Ok(conn) => conn,
+        Err(err) => {
+            let body = json!({ "error": format!("Pool error: {}", err) });
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(body));
+        }
+    };
+
+    let mut stmt = match conn.prepare(
+        "SELECT conversation_id, name FROM conversation_participants WHERE user_id = ?1",
+    ) {
+        Ok(s) => s,
+        Err(e) => {
+            let body = json!({ "error": format!("Prepare failed: {}", e) });
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(body) )
+        
+        }
+    };
+
+    let rows = match stmt.query_map(params![user_id], |row| {
+        let conversation_id: i32 = row.get(0)?;
+        let name: String = row.get(1)?;
+        Ok((conversation_id, name))
+    }) {
+        Ok(rows) => rows,
+        //Ok(_) => {}, IMPLEMENT NO CONV ?
+        Err(e) => {
+            let body = json!({ "error": format!("Query failed: {}", e) });
+            return (StatusCode::INTERNAL_SERVER_ERROR, Json(body));
+        }
+    };
+
+    
+    let mut map = HashMap::new();
+
+    // ✅ Iterate through the row results
+    for row_result in rows {
+        match row_result {
+            Ok((id, name)) => {
+                map.insert(id, name);
+            }
+            Err(e) => {
+                let body = json!({ "error": format!("Row parsing failed: {}", e) });
+                return (StatusCode::INTERNAL_SERVER_ERROR, Json(body));
+            }
+        }
+    }
+
+    let convs_string = serde_json::to_string(&map)
+        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, Json("error".to_string())));
+
+    let conv_map_json = to_value(map).unwrap();
+    (StatusCode::OK, Json(conv_map_json))
+}
+
+
+
+
+/*
+pub async fn get_convs(
+    State(state): State<AppState>,
+    //Path((item_name, item_amount)): Path<(String, i32)>,
+    AuthClaims{ user_id, hotel_id}: AuthClaims,
+) -> impl IntoResponse {
+
+    let pool = state.hotel_pools.get_pool(hotel_id);
+
+    let conn = match pool.get(){
+        Ok(conn) => conn,
+        Err(err) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("Pool error: {}", err).into_response() )
+        
+    };
+
+    let mut stmt = match conn.prepare(
+        "SELECT id, title FROM conversation WHERE creator_id = ?1",
+    ) {
+        Ok(s) => s,
+        Err(e) => 
+            
+            return (StatusCode::INTERNAL_SERVER_ERROR, format!("Prepare failed: {}", e).into_response() )
+        
+        
+    };
+
+    let rows = match stmt.query_map(params![user_id], |row| {
+        let id: i32 = row.get(0)?;
+        let title: String = row.get(1)?;
+        Ok((title, id))
+    }) {
+        Ok(rows) => rows,
+        Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("Query failed: {}", e).into_response() )
+        
+    };
+
+    
+    let mut map = HashMap::new();
+
+    // ✅ Iterate through the row results
+    for row_result in rows {
+        match row_result {
+            Ok((title, id)) => {
+                map.insert(title, id);
+            }
+            Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("Row parsing failed: {}", e).into_response() )
+            
+        }
+    }
+
+
+    let conv_map_json =  match to_value(map) {
+        Ok(c) => c,
+        Err(e) => return (StatusCode::INTERNAL_SERVER_ERROR, format!("List unwrapping failed: {}", e).into_response() )
+    };
+    
+    let conv_map_clean_json = serde_json::to_value(map)
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Serialization failed: {}", e).into_response() ));
+
+
+
+    (StatusCode::OK, Json(conv_map_clean_json)).into_response()
+}
+
+*/

src/chat/routes.rs

@@ -18,6 +18,7 @@ pub fn chat_routes() -> Router<AppState> {
         .route("/create_conversation", post (create_conversation)) 
         .route("/add_users_conv", put(add_user_to_conv))
         .route("/send_message", post(send_message))
+        .route("/get_conv", get(get_convs))
         .route("/get_message", get(get_message))
         .route("/hotel_users", get(get_hotel_users))