Added simple rooms api

Author: alarmfox

backend/src/main.rs

@@ -22,9 +22,13 @@ use web::{
     routes_login,
 };
 
-use crate::web::{
-    webtransport::{self, Certs},
-    SESSION_COOKIE_KEY,
+use crate::{
+    service::room,
+    web::{
+        routes_room,
+        webtransport::{self, Certs},
+        SESSION_COOKIE_KEY,
+    },
 };
 
 #[tokio::main]
@@ -50,6 +54,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let auth_service = auth::Service::new(db.clone(), email_service);
     let session_service = session::Service::new(db.clone());
+    let room_service = room::Service::new(db.clone());
 
     let key = general_purpose::STANDARD
         .decode("mN1GR7dsQ+Bj8NFIA+n/uvSbBcdyvHnVdFuJSJrQJ3g2/8gGYaATt3Wv7j3xKpD07652no/eddRdD7sJTVjg4w==")
@@ -72,9 +77,9 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         },
     };
 
-    let app = Router::new().route("/test", get(|| async { "Hello world" }));
 
-    let app = app
+    let app = Router::new()
+        .nest("/api/rooms", routes_room::router(room_service))
         .layer(middleware::from_fn(mw_ctx_require))
         .nest(
             "/api/auth",

backend/src/service/mod.rs

@@ -1,3 +1,4 @@
 pub mod email;
 pub mod error;
+pub mod room;
 pub mod user;

backend/src/service/room.rs

@@ -0,0 +1,102 @@
+use std::{collections::HashMap, default, sync::Arc};
+
+use axum::extract::FromRef;
+use sqlx::{prelude::FromRow, PgPool};
+use time::PrimitiveDateTime;
+use tokio::sync::Mutex;
+use uuid::Uuid;
+
+use super::{error::Error};
+
+struct Session {
+    current_people_listening: i32,
+    current_people_playing: i32,
+    max_people_playing: i32,
+}
+
+#[derive(Clone, FromRef)]
+pub struct Service {
+    db: PgPool,
+    sessions: Arc<Mutex<HashMap<Uuid, Session>>>,
+}
+
+#[derive(FromRow)]
+pub struct Room {
+    pub id: Uuid,
+    pub name: String,
+    pub description: Option<String>,
+    pub owner: String,
+    pub private: bool,
+    pub open: bool,
+    pub max_people_playing: i32,
+    pub created_at: PrimitiveDateTime,
+    pub updated_at: PrimitiveDateTime,
+}
+
+
+impl Service {
+    pub fn new(db: PgPool) -> Self {
+        Self {
+            db,
+            sessions: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+}
+
+// crud operations
+impl Service {
+    pub async fn create(
+        &self,
+        owner: String,
+        name: String,
+        description: Option<String>,
+        private: bool,
+        open: bool,
+        max_people_playing: i32,
+    ) -> Result<Room, Error> {
+        let id = Uuid::new_v4();
+        let room = sqlx::query_as!(
+            Room,
+            r#"INSERT INTO rooms (id, owner, name, description, private, open, max_people_playing) 
+            VALUES ($1, $2, $3, $4, $5, $6, $7)
+            RETURNING *
+            "#,
+            id,
+            owner,
+            name,
+            description,
+            private,
+            open,
+            max_people_playing
+        )
+        .fetch_one(&self.db)
+        .await?;
+
+        self.sessions.lock().await.insert(
+            id,
+            Session {
+                current_people_playing: 0,
+                current_people_listening: 0,
+                max_people_playing,
+            },
+        );
+
+        Ok(room)
+    }
+
+    pub async fn get_by_id(&self, id: Uuid) -> Result<Option<Room>, Error> {
+        let room = sqlx::query_as!(Room, "SELECT * FROM rooms WHERE id = $1", id)
+            .fetch_optional(&self.db)
+            .await?;
+
+        Ok(room)
+    }
+
+    pub async fn delete(&self, id: Uuid) -> Result<(), Error> {
+        sqlx::query!(r#"DELETE FROM rooms WHERE id = $1"#, id)
+            .execute(&self.db)
+            .await?;
+
+        Ok(())
+    }
+}

backend/src/web/error.rs

@@ -38,6 +38,9 @@ pub enum Error {
     #[error(transparent)]
     #[serde(skip)]
     AxumJsonRejection(#[from] JsonRejection),
+
+    NotAllowed,
+    NotFound
 }
 
 // region:    --- Axum IntoResponse
@@ -83,6 +86,10 @@ impl Error {
 
             // -- Auth
             CtxExt(_) => (StatusCode::FORBIDDEN, ClientError::NO_AUTH),
+            NotAllowed => (StatusCode::FORBIDDEN, ClientError::NOT_ALLOWED),
+
+            // -- Model
+            NotFound => (StatusCode::NOT_FOUND, ClientError::NOT_FOUND),
 
             // -- Fallback.
             _ => (
@@ -100,5 +107,7 @@ pub enum ClientError {
     LOGIN_FAIL,
     NO_AUTH,
     SERVICE_ERROR,
+    NOT_ALLOWED,
+    NOT_FOUND,
 }
 // endregion: --- Client Error

backend/src/web/mod.rs

@@ -5,11 +5,12 @@ pub mod context;
 pub mod error;
 pub mod json;
 pub mod mw_auth;
-pub mod mw_res_map;
 pub mod mw_req_stamp;
+pub mod mw_res_map;
 pub mod routes_login;
+pub mod routes_room;
 pub mod signed_cookies;
 pub mod webtransport;
 
 pub const SESSION_COOKIE_NAME: &str = "session-id";
-pub static SESSION_COOKIE_KEY: OnceCell<Key> = OnceCell::const_new(); 
+pub static SESSION_COOKIE_KEY: OnceCell<Key> = OnceCell::const_new();

backend/src/web/routes_room.rs

@@ -0,0 +1,81 @@
+use crate::service::room::{self, Room};
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::{delete, post},
+    Json as AJson, Router,
+};
+use common::types::{CreateRoomRequest, RoomResponse};
+
+use super::{
+    error::{Error, Result},
+    json::Json,
+    mw_auth::CtxW,
+};
+
+#[derive(Clone)]
+struct AppState {
+    room_service: room::Service,
+}
+
+pub fn router(room_service: room::Service) -> Router {
+    Router::new()
+        .route("/", post(create))
+        .route("/:id", delete(delete_room).get(get_by_id))
+        .with_state(AppState { room_service })
+}
+
+async fn create(
+    context: CtxW,
+    State(AppState { room_service }): State<AppState>,
+    Json(CreateRoomRequest { name }): Json<CreateRoomRequest>,
+) -> Result<impl IntoResponse> {
+    let username = context.0.get_session().username;
+
+    let room = room_service
+        .create(username, name, None, false, true, 5)
+        .await?;
+
+    Ok((StatusCode::CREATED, AJson(RoomResponse::from(room))))
+}
+
+async fn delete_room(
+    Path(id): Path<uuid::Uuid>,
+    State(AppState { room_service, .. }): State<AppState>,
+    context: CtxW,
+) -> Result<impl IntoResponse> {
+    let room = room_service.get_by_id(id).await?;
+    if let Some(room) = room {
+        if room.owner != context.0.get_session().username {
+            return Err(Error::NotAllowed);
+        }
+
+        room_service.delete(id).await?;
+    }
+    Ok(StatusCode::NO_CONTENT)
+}
+
+async fn get_by_id(
+    Path(id): Path<uuid::Uuid>,
+    State(AppState { room_service }): State<AppState>,
+) -> Result<impl IntoResponse> {
+    let room = room_service.get_by_id(id).await?;
+
+    if let Some(room) = room {
+        Ok(AJson(RoomResponse::from(room)))
+    } else {
+        Err(Error::NotFound)
+    }
+
+}
+
+impl From<Room> for RoomResponse {
+    fn from(
+        Room {
+            id, name, owner, ..
+        }: Room,
+    ) -> Self {
+        Self { id, name, owner }
+    }
+}

common/src/types.rs

@@ -63,3 +63,14 @@ pub struct StartResetRequest{
     #[validate(email(message = "Invalid email"))]
     pub email: String,
 }
+
+#[derive(Serialize, Deserialize, Clone, Validate)]
+pub struct CreateRoomRequest {
+    pub name: String,
+}
+#[derive(Serialize, Deserialize, Clone)]
+pub struct RoomResponse {
+    pub id: Uuid,
+    pub name: String,
+    pub owner: String,
+}

frontend/src/components/pages/classes.rs

@@ -9,9 +9,7 @@ pub fn main_div_classes() -> Classes {
         "items-center",
         "justify-center",
         "px-6",
-        "py-8",
         "mx-auto",
-        "lg:py-0"
     )
 }