first implementation of /syncs/progress

src/main.rs

@@ -2,18 +2,27 @@ use axum::{
     http::HeaderMap, http::StatusCode, routing::get, routing::post, routing::put, Json, Router,
 };
 
-use serde_json::{json, Value};
-
 use serde::Deserialize;
 
 use redis::Commands;
 
+use std::time::{SystemTime, UNIX_EPOCH};
+
 #[derive(Deserialize)]
 pub struct User {
     username: String,
     password: String,
 }
 
+#[derive(Deserialize)]
+pub struct Progress {
+    document: String,
+    progress: String,
+    percentage: String,
+    device: String,
+    device_id: String,
+}
+
 #[tokio::main]
 async fn main() {
     // build our application with a single route
@@ -22,7 +31,7 @@ async fn main() {
         .route("/users/create", post(create_user))
         .route("/users/auth", get(auth_user))
         .route("/syncs/progress", put(update_progress))
-        .route("/syncs/progress/:document", put(get_progress))
+        .route("/syncs/progress/:document", get(get_progress))
         .route("/healthcheck", get(healthcheck));
 
     // run it with hyper on localhost:3000
@@ -59,14 +68,33 @@ async fn create_user(Json(payload): Json<User>) -> (StatusCode, String) {
     (StatusCode::CREATED, format!("username = {username}"))
 }
 
-async fn auth_user(headers: HeaderMap) -> StatusCode {
+fn authorize(username: &str, password: &str) -> bool {
     let client = redis::Client::open("redis://127.0.0.1/").unwrap();
     let mut con = client.get_connection().unwrap();
 
+    if username.is_empty() || password.is_empty() {
+        return false;
+    }
+
+    let user_key = format!("user:{username}:key");
+
+    let redis_pw: String = con.get(&user_key).unwrap();
+
+    if password != redis_pw {
+        return false;
+    }
+
+    true
+}
+
+async fn auth_user(headers: HeaderMap) -> StatusCode {
+    //let client = redis::Client::open("redis://127.0.0.1/").unwrap();
+    //let mut con = client.get_connection().unwrap();
+
     let username = headers["x-auth-user"].to_str().unwrap_or("");
     let password = headers["x-auth-key"].to_str().unwrap_or("");
 
-    if username.is_empty() || password.is_empty() {
+    /*if username.is_empty() || password.is_empty() {
         return StatusCode::UNAUTHORIZED;
     }
 
@@ -76,12 +104,48 @@ async fn auth_user(headers: HeaderMap) -> StatusCode {
 
     if password != redis_pw {
         return StatusCode::UNAUTHORIZED;
+    }*/
+
+    if authorize(&username, &password) == false {
+        return StatusCode::UNAUTHORIZED;
     }
 
     StatusCode::OK
 }
 
-async fn update_progress() {}
+async fn update_progress(headers: HeaderMap, Json(payload): Json<Progress>) -> StatusCode {
+    let username = headers["x-auth-user"].to_str().unwrap_or("");
+    let password = headers["x-auth-key"].to_str().unwrap_or("");
+
+    if authorize(username, password) == false {
+        return StatusCode::UNAUTHORIZED;
+    }
+
+    let client = redis::Client::open("redis://127.0.0.1/").unwrap();
+    let mut con = client.get_connection().unwrap();
+
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap()
+        .as_secs();
+    let document = payload.document;
+
+    let doc_key = format!("user:{username}:document:{document}");
+    let _: () = con
+        .hset_multiple(
+            &doc_key,
+            &[
+                ("percentage", &payload.percentage),
+                ("progress", &payload.progress),
+                ("device", &payload.device),
+                ("device_id", &payload.device_id),
+                ("timestamp", &timestamp.to_string()),
+            ],
+        )
+        .unwrap();
+
+    StatusCode::OK
+}
 
 async fn get_progress() {}