1 files changed, 65 insertions, 130 deletions

diff --git a/src/main.rs b/src/main.rs
index 603d714..281b63b 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,7 +1,5 @@
 #[macro_use] extern crate rocket;
 
-use std::{fs::File, io::Write, vec};
-
 use rocket::{http::Status, serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 
@@ -9,148 +7,53 @@ mod uid;
 use tokio::sync::Mutex;
 use uid::UID;
 
-#[derive(Debug, Serialize, Deserialize, Clone, Copy)]
-enum Color {
-    White,
-    Red,
-    Blue,
-    Green,
-    Yellow,
-}
+mod db;
+use db::DB;
+use db::User;
+use db::Config;
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct Token {
-    color: Color,
-    amount: usize,
-}
-impl Token {
-    pub fn new(color: Color, amount: usize) -> Token {
-        Token { color, amount }
-    }
+#[get("/")]
+async fn index() -> &'static str {
+    "This is a POKO server"
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-struct User {
+
+#[derive(Serialize)]
+struct UserOut {
     name: String,
-    id: UID,
-    tokovec: Vec<Token>
+    id: String,
 }
-impl User {
-    pub fn new(name: String, id: UID) -> User {
-        let base_tokens = vec![
-            Token::new(Color::White, 2),
-            Token::new(Color::Red, 2),
-            Token::new(Color::Blue, 2),
-            Token::new(Color::Green, 2),
-            Token::new(Color::Yellow, 2),
-        ];
-        User { name: name, id: id, tokovec: base_tokens }
+impl Into<UserOut> for User {
+    fn into(self) -> UserOut {
+        UserOut { name: self.get_name(), id: self.hex_id() }
     }
 }
 
-const DBSAVE: &str = "db.json";
-
-#[derive(Serialize, Deserialize)]
-struct DB {
-    uid_generator: uid::Generator,
-    users: Vec<User>,
-}
-impl DB {
-    async fn save(&self) -> Result<(), String> {
-        let mut f = match File::create(DBSAVE) {
-            Ok(n) => n,
-            Err(n) => {
-                match n.kind() {
-                    std::io::ErrorKind::PermissionDenied => panic!("{}: Permission Denied", DBSAVE),
-                    n => return Err(n.to_string()),
-                }
-            },
-        };
-        let s = match serde_json::to_string(self) {
-            Ok(n) => n,
-            Err(n) => return Err(n.to_string()),
-        };
-        match f.write(s.as_bytes()) {
-            Ok(_) => return Ok(()),
-            Err(n) => return Err(n.to_string()),
-        };
-    }
-    pub fn load() -> Self {
-        match File::open(DBSAVE) {
-            Ok(n) => {
-                match serde_json::from_reader(n) {
-                    Ok(n) => n,
-                    Err(n) => panic!("{}", n),
-                }
-            },
-            Err(n) => match n.kind() {
-                std::io::ErrorKind::PermissionDenied => panic!("{}: Permission Denied", DBSAVE),
-                _ => DB::new(),
-            },
-        }
-    }
-    pub fn new() -> Self {
-        DB { uid_generator: uid::Generator::new(), users: vec![] }
-    }
-
-    async fn get_user(&self, id: &str) -> Result<User, String> {
-        match UID::from(id.to_string()) {
-            Ok(n) => {
-                for u in self.users.clone() {
-                    if u.id == n {
-                        return Ok(u)
-                    }
-                }
-            },
-            Err(_) => (),
-        }
-
-        Err("Not Found".into())
-    }
-    async fn get_user_by_name(&self, name: &str) -> Result<Vec<User>, String> {
-        let mut vec = vec![];
-        for u in self.users.clone() {
-            if u.name == name {
-                vec.push(u)
-            }
-        }
-
-        if vec.len() == 0 {
-            Err("Not Found".into())
-        } else {
-            return Ok(vec)
-        }
-
-    }
-
-    async fn new_user(&mut self, name: String, id: UID) -> Result<(), String> {
-        let user = User::new(name, id);
-        self.users.push(user);
-        self.save().await
-    }
-}
-
-#[get("/")]
-async fn index() -> &'static str {
-    "This is a POKO server"
-}
-
-#[get("/user/<user>")]
-async fn get_user(user: &str, db: &State<Mutex<DB>>) -> (Status, Result<Json<User>, Json<String>>) {
-    let db = db.lock().await;
+#[get("/<user>")]
+async fn get_user(user: &str, db: &State<Mutex<DB>>) -> (Status, Result<Json<UserOut>, Json<String>>) {
+    let mut db = db.lock().await;
     match db.get_user(user).await {
-        Ok(n) => (Status::Ok, Ok(n.into())),
+        Ok(n) => (Status::Ok, Ok(Json(n.clone().into()))),
         Err(n) => (Status::NotFound, Err(n.into()))
     }
 }
-#[get("/user/by_name/<user>")]
-async fn get_users_by_name(user: &str, db: &State<Mutex<DB>>) -> (Status, Result<Json<Vec<User>>, Json<String>>) {
+#[get("/by_name/<user>")]
+async fn get_users_by_name(user: &str, db: &State<Mutex<DB>>) -> (Status, Result<Json<Vec<UserOut>>, Json<String>>) {
     let db = db.lock().await;
     match db.get_user_by_name(user).await {
-        Ok(n) => (Status::Ok, Ok(n.into())),
+        Ok(n) => (Status::Ok, Ok(Json(n.into_iter().map(|v| v.into()).collect()))),
         Err(n) => (Status::NotFound, Err(n.into()))
     }
 }
+#[get("/all")]
+async fn get_all_users(db: &State<Mutex<DB>>) -> (Status, Result<Json<Vec<UserOut>>, Json<String>>) {
+    let db = db.lock().await;
+    match db.get_all_users().await {
+        Ok(n) => (Status::Ok, Ok(Json(n.into_iter().map(|v| v.into()).collect()))),
+        //Nothing found
+        Err(n) => (Status::NotFound, Err(n.into())),
+    }
+}
 
 fn default_id() -> String {
     "random".into()
@@ -158,10 +61,11 @@ fn default_id() -> String {
 #[derive(Deserialize)]
 struct UserForm {
     name: String,
+    password: String,
     #[serde(default = "default_id")]
     id: String,
 }
-#[post("/user", data="<data>", format="json")]
+#[post("/register", data="<data>", format="json")]
 async fn new_user(data: Json<UserForm>, db: &State<Mutex<DB>>) -> (Status, Result<(), Json<String>>) {
     let mut db = db.lock().await;
     let id;
@@ -198,7 +102,7 @@ async fn new_user(data: Json<UserForm>, db: &State<Mutex<DB>>) -> (Status, Resul
     match id {
         None => return (Status::InternalServerError, Err("".to_string().into())),
         Some(n) => {
-            match db.new_user(data.name.clone(), n).await {
+            match db.new_user(data.name.clone(), data.password.clone(), n).await {
                 // User has been created
                 Ok(_) => return (Status::Created, Ok(())),
                 // Could not create user
@@ -208,7 +112,38 @@ async fn new_user(data: Json<UserForm>, db: &State<Mutex<DB>>) -> (Status, Resul
     }
 }
 
+#[derive(Deserialize)]
+struct LoginForm {
+    id: String,
+    password: String,
+    clientid: String,
+}
+#[post("/", data="<data>", format="json")]
+async fn login(data: Json<LoginForm>, db: &State<Mutex<DB>>) -> (Status, Json<String>) {
+    let mut db = db.lock().await;
+    match db.login(&data.id, &data.password, &data.clientid).await {
+        Ok(n) => (Status::Ok, n.into()),
+        Err(n) => (Status::Unauthorized, n.into()),
+    }
+}
+
+#[derive(Deserialize)]
+struct LogoutForm {
+    id: String,
+    sessionhash: String,
+}
+#[post("/logout", data="<data>", format="json")]
+async fn logout(data: Json<LogoutForm>, db: &State<Mutex<DB>>) -> (Status, Result<(), String>) {
+    let mut db = db.lock().await;
+    match db.logout(&data.id, &data.sessionhash).await {
+        Ok(_) => (Status::Ok, Ok(())),
+        Err(n) => (Status::Unauthorized, Err(n)),
+    }
+}
+
 #[launch]
 fn rocket() -> _ {
-    rocket::build().manage(Mutex::new(DB::load())).mount("/", routes![index, new_user, get_user, get_users_by_name])
+    rocket::build().manage(Mutex::new(DB::load(Config::new())))
+    .mount("/", routes![index])
+    .mount("/user", routes![login, get_users_by_name, get_user, new_user, get_all_users, logout])
 }
\ No newline at end of file