Added endpoints to server

.gitignore

@@ -5,4 +5,5 @@ Cargo.lock
 database.db-shm
 database.db-wal
 priv.pem
-pub.pem
+pub.pem
+images/*

migrations/20250312172645_revoked_table.sql

@@ -1,5 +1,6 @@
 -- Add migration script here
 CREATE TABLE IF NOT EXISTS revoked (
   'token_id' INTEGER NOT NULL,
-  'user_id' VARCHAR NOT NULL
+  'user_id' VARCHAR NOT NULL,
+  'expires' INTEGER NOT NULL
 )

src/cases.rs

@@ -0,0 +1,61 @@
+use crate::AppState;
+use actix_web::web::Data;
+use actix_web::{get, web, HttpResponse, Responder};
+use serde::{Deserialize, Serialize};
+use serde_json::to_string;
+use sqlx::query_as;
+use crate::types::*;
+
+
+#[get("/case")]
+async fn get_case(query: web::Query<DataUuid>, app_state: Data<AppState>) -> impl Responder {
+    let case = query_as!(Case, "SELECT * FROM cases WHERE uuid = $1", query.uuid).fetch_one(&app_state.database).await;
+    if case.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let json = to_string(&case.unwrap());
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}
+
+#[get("/cases")]
+async fn get_cases(app_state: Data<AppState>) -> impl Responder {
+    let cases = query_as!(Case, "SELECT * FROM cases").fetch_all(&app_state.database).await;
+    if cases.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let json = to_string(&cases.unwrap());
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}
+
+
+#[get("/case-items")]
+async fn get_case_items(query: web::Query<DataUuid>, app_state: Data<AppState>) -> impl Responder {
+    let case = query_as!(Case, "SELECT * FROM cases WHERE uuid = $1", query.uuid).fetch_one(&app_state.database).await;
+    if case.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let case = case.unwrap();
+    let items_cases = query_as!(ItemCases, "SELECT * FROM items_cases WHERE \"case\" = $1", case.id).fetch_all(&app_state.database).await;
+    if items_cases.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let items_cases = items_cases.unwrap();
+    let mut items = vec![];
+    for item_case in items_cases {
+        if let Ok(item) = query_as!(Item, "SELECT * FROM items WHERE id = $1", item_case.item).fetch_one(&app_state.database).await {
+            items.push(item);
+        }
+    }
+    let json = to_string(&items);
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}
+

src/items.rs

@@ -0,0 +1,59 @@
+use actix_web::{get, web, HttpResponse, Responder};
+use actix_web::web::Data;
+use serde::{Deserialize, Serialize};
+use serde_json::to_string;
+use sqlx::query_as;
+use crate::AppState;
+use crate::types::*;
+
+
+#[get("/item")]
+async fn get_item(query: web::Query<DataUuid>, app_state: Data<AppState>) -> impl Responder {
+    let item = query_as!(Item, "SELECT * FROM items WHERE uuid = $1", query.uuid).fetch_one(&app_state.database).await;
+    if item.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let json = to_string(&item.unwrap());
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}
+
+#[get("/items")]
+async fn get_items(app_state: Data<AppState>) -> impl Responder {
+    let items = query_as!(Item, "SELECT * FROM items").fetch_all(&app_state.database).await;
+    if items.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let json = to_string(&items.unwrap());
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}
+
+#[get("/item-cases")]
+async fn get_item_cases(query: web::Query<DataUuid>, app_state: Data<AppState>) -> impl Responder {
+    let item = query_as!(Item, "SELECT * FROM items WHERE uuid = $1", query.uuid).fetch_one(&app_state.database).await;
+    if item.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let item = item.unwrap();
+    let items_cases = query_as!(ItemCases, "SELECT * FROM items_cases WHERE \"item\" = $1", item.id).fetch_all(&app_state.database).await;
+    if items_cases.is_err() {
+        return HttpResponse::NotFound().finish();
+    }
+    let items_cases = items_cases.unwrap();
+    let mut cases = vec![];
+    for item_case in items_cases {
+        if let Ok(item) = query_as!(Case, "SELECT * FROM cases WHERE id = $1", item_case.item).fetch_one(&app_state.database).await {
+            cases.push(item);
+        }
+    }
+    let json = to_string(&cases);
+    if json.is_err() {
+        return HttpResponse::InternalServerError().finish();
+    }
+    HttpResponse::Ok().body(json.unwrap())
+}

src/main.rs

@@ -1,6 +1,11 @@
 mod users;
+mod cases;
+mod items;
+mod types;
 
 use users::*;
+use cases::*;
+use items::*;
 
 use actix_web::web::Data;
 use actix_web::{App, HttpServer};
@@ -26,6 +31,12 @@ async fn main() -> std::io::Result<()> {
             .service(login)
             .service(register)
             .service(logout)
+            .service(get_case)
+            .service(get_cases)
+            .service(get_item)
+            .service(get_items)
+            .service(get_case_items)
+            .service(get_item_cases)
             .app_data(app_state.clone())
     })
         .bind(("127.0.0.1", 8000))?

src/types.rs

@@ -0,0 +1,31 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct ItemCases {
+    pub item: i64,
+    pub case: i64,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct DataUuid {
+    pub uuid: String,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Case {
+    pub id: i64,
+    pub uuid: String,
+    pub name: String,
+    pub image: String,
+    pub price: f64,
+}
+
+#[derive(Serialize)]
+pub struct Item {
+    pub id: i64,
+    pub uuid: String,
+    pub name: String,
+    pub rarity: i64,
+    pub image: String,
+    pub price: f64,
+}

src/users.rs

@@ -110,10 +110,12 @@ async fn logout(req: HttpRequest, app_state: Data<AppState>) -> impl Responder {
     );
     match token {
         Ok(token) => {
+            let exp = token.claims.exp as i64;
             if query!(
-                "INSERT INTO revoked ( token_id, user_id ) VALUES ( $1, $2 )",
+                "INSERT INTO revoked ( token_id, user_id, expires ) VALUES ( $1, $2, $3 )",
                 token.claims.kid,
-                token.claims.uid
+                token.claims.uid,
+                exp
             )
                 .execute(&app_state.database)
                 .await