feat(problem): list all problems from specific user

.changes/list-problem.md

@@ -0,0 +1,5 @@
+---
+"algohub-server": patch:feat
+---
+
+Add method for listing all problems from specific user.

src/models/account.rs

@@ -114,8 +114,3 @@ pub struct Session {
     pub account_id: Thing,
     pub token: String,
 }
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct Record {
-    id: Option<Thing>,
-}

src/models/mod.rs

@@ -1,11 +1,7 @@
-use serde::Serialize;
-
 pub mod account;
 pub mod error;
 pub mod problem;
 pub mod response;
+pub mod shared;
 
-#[derive(Serialize)]
-pub struct UpdateAt {
-    pub updated_at: chrono::NaiveDateTime,
-}
+pub use shared::*;

src/models/problem.rs

@@ -69,7 +69,7 @@ impl From<ProblemData<'_>> for Problem {
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct ProblemDetail {
     pub id: Thing,
 

src/models/shared.rs

@@ -0,0 +1,19 @@
+use serde::{Deserialize, Serialize};
+use surrealdb::sql::Thing;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Record {
+    id: Option<Thing>,
+}
+
+#[derive(Serialize)]
+pub struct UpdateAt {
+    pub updated_at: chrono::NaiveDateTime,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct Credential<'c> {
+    pub id: &'c str,
+    pub token: &'c str,
+}

src/routes/account.rs

@@ -16,9 +16,10 @@ use surrealdb::{engine::remote::ws::Client, Surreal};
 
 use crate::{
     models::{
-        account::{Profile, Record},
+        account::Profile,
         error::{Error, ErrorResponse},
         response::{Empty, Response},
+        Record,
     },
     utils::{account, session},
     Result,

src/routes/problem.rs

@@ -17,6 +17,7 @@ use crate::{
         error::Error,
         problem::{Mode, Problem, ProblemDetail, Sample},
         response::Response,
+        Credential,
     },
     utils::{problem, session},
     Result,
@@ -50,7 +51,7 @@ pub struct ProblemData<'r> {
     pub private: bool,
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(Serialize, Deserialize, Debug)]
 #[serde(crate = "rocket::serde")]
 pub struct ProblemResponse {
     pub id: String,
@@ -128,6 +129,27 @@ pub async fn get(
     }))
 }
 
+#[post("/list", data = "<auth>")]
+pub async fn list(
+    db: &State<Surreal<Client>>,
+    auth: Json<Credential<'_>>,
+) -> Result<Vec<ProblemDetail>> {
+    if !session::verify(db, auth.id, auth.token).await {
+        return Err(Error::Unauthorized(Json("Invalid token".into())));
+    }
+
+    let problems = problem::list(db, auth.id)
+        .await
+        .map_err(|e| Error::ServerError(Json(e.to_string().into())))?;
+    println!("{:?}", problems);
+
+    Ok(Json(Response {
+        success: true,
+        message: "Problems found".to_string(),
+        data: Some(problems),
+    }))
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct SubmitData<'r> {
     pub id: &'r str,
@@ -234,5 +256,5 @@ pub async fn submit(
 
 pub fn routes() -> Vec<rocket::Route> {
     use rocket::routes;
-    routes![create, get, submit]
+    routes![create, get, submit, list]
 }

src/utils/problem.rs

@@ -31,3 +31,14 @@ where
 {
     Ok(db.select(("problem", id)).await?)
 }
+
+pub async fn list<M>(db: &Surreal<Client>, id: &str) -> Result<Vec<M>>
+where
+    for<'de> M: Deserialize<'de>,
+{
+    Ok(db
+        .query("SELECT * FROM problem WHERE owner = type::thing(\"account\", $id)")
+        .bind(("id", id.to_string()))
+        .await?
+        .take(0)?)
+}

tests/problem.rs

@@ -0,0 +1,115 @@
+use algohub_server::{
+    models::{
+        problem::{Mode, ProblemDetail},
+        response::{Empty, Response},
+        Credential,
+    },
+    routes::{
+        account::{Authenticate, RegisterData, RegisterResponse},
+        problem::{ProblemData, ProblemResponse},
+    },
+};
+use anyhow::Result;
+use rocket::local::asynchronous::Client;
+
+#[rocket::async_test]
+async fn test_problem() -> Result<()> {
+    let rocket = algohub_server::rocket().await;
+
+    let client = Client::tracked(rocket).await?;
+
+    println!("Testing register...");
+    let response = client
+        .post("/account/create")
+        .json(&RegisterData {
+            username: "fu050409".to_string(),
+            password: "password".to_string(),
+            email: "[email protected]".to_string(),
+        })
+        .dispatch()
+        .await;
+
+    assert_eq!(response.status().code, 200);
+
+    let Response {
+        success,
+        message: _,
+        data,
+    } = response.into_json().await.unwrap();
+    let data: RegisterResponse = data.unwrap();
+
+    let id = data.id.clone();
+    let token = data.token.clone();
+
+    assert!(success);
+    println!("Registered account: {:?}", &data);
+
+    for i in 0..10 {
+        let response = client
+            .post("/problem/create")
+            .json(&ProblemData {
+                id: &id,
+                token: &token,
+                title: &format!("Test Problem #{}", i),
+                description: "Test Description".to_string(),
+                input: Some("Test Input".to_string()),
+                output: Some("Test Output".to_string()),
+                samples: vec![],
+                hint: None,
+
+                time_limit: 1000,
+                memory_limit: 128,
+                test_cases: vec![],
+                categories: vec![],
+                tags: vec![],
+                mode: Mode::ICPC,
+                private: true,
+            })
+            .dispatch()
+            .await;
+
+        assert_eq!(response.status().code, 200);
+
+        let Response {
+            success,
+            message: _,
+            data,
+        } = response.into_json().await.unwrap();
+        let data: ProblemResponse = data.unwrap();
+
+        assert!(success);
+        println!("Created problem: {:?}", &data);
+    }
+
+    let response = client
+        .post("/problem/list")
+        .json(&Credential {
+            id: &id,
+            token: &token,
+        })
+        .dispatch()
+        .await;
+
+    let Response {
+        success,
+        message: _,
+        data,
+    } = response
+        .into_json::<Response<Vec<ProblemDetail>>>()
+        .await
+        .unwrap();
+    let data = data.unwrap();
+    assert!(success);
+    assert_eq!(data.len(), 10);
+
+    client
+        .post(format!("/account/delete/{}", id))
+        .json(&Authenticate { token: &token })
+        .dispatch()
+        .await
+        .into_json::<Response<Empty>>()
+        .await
+        .unwrap();
+
+    Ok(())
+}