Dev

Astrox.toml

@@ -3,7 +3,8 @@ port = 8080
 env = "dev"
 astro_port = 5431
 prod_astro_build = true
-cors_url = "https://astrox.spaceout.pl"
+cors_url = "http://localhost:5431"
 
 [public_keys]
-public_api_url = "https://astrox.spaceout.pl/api"
+public_api_url = "http://localhost:8080/api"
+public_ws_url = "ws://localhost:8080/ws/"

src/backend/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+uuid = { version = "1.15.1", features = ["v4"]}
 actix-web = "4"
 actix-rt = "2"
 actix-files = "0.6.6"
@@ -18,9 +19,14 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 reqwest = { version = "0.12", features = ["json"] }
 env_logger = "0.11.5"
+log = "*"
 anyhow = "1.0"
 dotenv = "0.15.0"
 thiserror = "1.0.63"
 pin-project = "1.1.5"
 futures = "0.3.30"
 globset = "0.4.14"
+actix-ws = "0.3.0"
+tokio = { version="*", features = ["rt", "time", "macros"] }
+
+

src/backend/src/api/mod.rs

@@ -1,2 +1 @@
-pub mod hello;
-pub mod space_x;
+pub mod room;

src/backend/src/api/room/create_room.rs

@@ -0,0 +1,46 @@
+use actix_session::Session;
+use actix_web::{web, HttpResponse, Responder};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::room::room_manager::AppState;
+
+#[derive(Deserialize)]
+pub struct CreateRoomRequest {
+    pub room_name: String,
+    pub user_name: String,
+}
+
+#[derive(Serialize)]
+pub struct CreateRoomResponse {
+    pub room_name: String,
+    pub room_id: String,
+    pub user_name: String,
+}
+
+pub async fn create_room(
+    data: web::Data<Arc<AppState>>,
+    session: Session,
+    req: web::Json<CreateRoomRequest>,
+) -> impl Responder {
+    let room_name = req.room_name.clone();
+    let user_name = req.user_name.clone();
+    let room_id = Uuid::new_v4().to_string();
+
+    // Store user name in session
+    session.insert("user_name", &user_name).unwrap();
+    session.insert("room_name", &room_name).unwrap();
+    session.insert("room_id", &room_id).unwrap();
+
+    // Add room
+    data.add_room(room_id.clone(), room_name.clone(), user_name.clone());
+
+    let response = CreateRoomResponse {
+        room_name,
+        room_id,
+        user_name,
+    };
+
+    HttpResponse::Ok().json(response)
+}

src/backend/src/api/room/create_room_session.rs

@@ -0,0 +1,47 @@
+use actix_session::Session;
+use actix_web::{web, HttpResponse, Responder};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::room::room_manager::AppState;
+
+#[derive(Deserialize)]
+pub struct CreateRoomRequest {
+    pub room_name: String,
+}
+
+#[derive(Serialize)]
+pub struct CreateRoomResponse {
+    pub room_name: String,
+    pub room_id: String,
+    pub user_name: String,
+}
+
+pub async fn create_room_session(
+    data: web::Data<Arc<AppState>>,
+    session: Session,
+    req: web::Json<CreateRoomRequest>,
+) -> impl Responder {
+    let room_name = req.room_name.clone();
+    let user_name: String = match session.get("user_name") {
+        Ok(Some(name)) => name,
+        _ => return HttpResponse::Unauthorized().body("User not in session"),
+    };
+    let room_id = Uuid::new_v4().to_string();
+
+    // Store room details in session
+    session.insert("room_name", &room_name).unwrap();
+    session.insert("room_id", &room_id).unwrap();
+
+    // Add room
+    data.add_room(room_id.clone(), room_name.clone(), user_name.clone());
+
+    let response = CreateRoomResponse {
+        room_name,
+        room_id,
+        user_name,
+    };
+
+    HttpResponse::Ok().json(response)
+}

src/backend/src/api/room/get_room.rs

@@ -0,0 +1,66 @@
+use actix_session::Session;
+use actix_web::{web, HttpResponse, Responder};
+use serde::Serialize;
+use std::sync::Arc;
+
+use crate::room::room_manager::{AppState, Estimation};
+
+#[derive(Serialize)]
+pub struct RoomResponse<'a> {
+    pub id: &'a String,
+    pub name: &'a String,
+    pub owner: &'a String,
+    pub estimations: &'a Vec<Estimation>,
+    pub users: &'a Vec<String>,
+    pub current_estimation: u8,
+}
+
+pub async fn get_room(
+    data: web::Data<Arc<AppState>>,
+    session: Session,
+    room_id: web::Path<String>,
+) -> impl Responder {
+    let room_id = room_id.into_inner();
+    if let Some(room) = data.get_room(&room_id) {
+        let user_name: Option<String> = session.get("user_name").unwrap_or(None);
+        let user_is_owner = user_name.as_deref() == Some(&room.owner);
+
+        // if link is shared the user is not the owner
+        // add him to users list
+
+        if !user_is_owner {
+            // check if user on the users list
+            let user_already_in_room = room
+                .users
+                .iter()
+                .any(|u| u == user_name.as_deref().unwrap());
+            if !user_already_in_room {
+                let mut rooms = data.rooms.lock().unwrap();
+                let room = rooms.get_mut(&room_id).unwrap();
+                room.users.push(user_name.unwrap());
+            }
+        }
+
+        let response = RoomResponse {
+            id: &room.id,
+            name: &room.name,
+            owner: &room.owner,
+            current_estimation: room.current_estimation,
+            estimations: &room.estimations,
+            users: &room.users,
+        };
+
+        let ws_room = room.clone();
+
+        let ws_response = crate::api::room::ws_handler::ResponseMessageWS {
+            type_: "UserJoined".to_string(),
+            data: ws_room,
+        };
+
+        let serde_msg = serde_json::to_string(&ws_response).unwrap();
+        data.broadcast(&room_id, &serde_msg);
+        HttpResponse::Ok().json(response)
+    } else {
+        HttpResponse::NotFound().body("Room not found")
+    }
+}

src/backend/src/api/room/list_rooms.rs

@@ -0,0 +1,41 @@
+use actix_session::Session;
+use actix_web::{web, HttpResponse, Responder};
+use serde::Serialize;
+use std::sync::Arc;
+
+use crate::room::room_manager::AppState;
+
+#[derive(Serialize)]
+pub struct ListResponse {
+    pub username: String,
+    pub rooms: Vec<RoomInfo>,
+}
+
+#[derive(Serialize)]
+pub struct RoomInfo {
+    id: String,
+    name: String,
+}
+
+pub async fn list_rooms(data: web::Data<Arc<AppState>>, session: Session) -> impl Responder {
+    if let Some(user_name) = session.get::<String>("user_name").unwrap_or(None) {
+        let rooms = data.rooms.lock().unwrap();
+        let room_list: Vec<RoomInfo> = rooms
+            .iter()
+            .filter(|(_, room)| room.owner == user_name)
+            .map(|(id, room)| RoomInfo {
+                id: id.clone(),
+                name: room.name.clone(),
+            })
+            .collect();
+
+        let room_list_response = ListResponse {
+            username: user_name,
+            rooms: room_list,
+        };
+
+        HttpResponse::Ok().json(room_list_response)
+    } else {
+        HttpResponse::Unauthorized().body("User not logged in")
+    }
+}

src/backend/src/api/room/mod.rs

@@ -0,0 +1,5 @@
+pub mod create_room;
+pub mod create_room_session;
+pub mod get_room;
+pub mod list_rooms;
+pub mod ws_handler;