first implementation of /syncs/progress

This commit is contained in:
Martin Brodbeck 2023-09-26 14:14:01 +02:00
parent 25b5d51506
commit 19166d723c

View file

@ -6,12 +6,23 @@ 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
@ -20,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
@ -57,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;
}
@ -74,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() {}