From 9d8ea69fee5b26d804529d877d54c01229ba2322 Mon Sep 17 00:00:00 2001
From: curly <curlybryce@protonmail.com>
Date: Tue, 7 Feb 2023 13:44:31 -0700
Subject: I hate sql

---
 src/main.rs | 194 +++++-------------------------------------------------------
 1 file changed, 15 insertions(+), 179 deletions(-)

(limited to 'src/main.rs')

diff --git a/src/main.rs b/src/main.rs
index f6163ab..a9db22e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,11 +1,17 @@
 #[macro_use] extern crate rocket;
+
+mod database;
+
 use rocket::serde::json::Json;
-use std::collections::HashMap;
 use rocket::State;
 use std::sync::Mutex;
-use std::time::SystemTime;
+use database::types::{Message, User, Info};
 
 
+struct SharedDB {
+    sdb: Mutex<database::Database>
+}
+
 #[derive(serde::Serialize)]
 struct Response<T, Y> (Result<T, Y>);
 
@@ -48,8 +54,8 @@ fn send_message(user_id: usize, msg: String, db: &State<SharedDB>) -> Json<Respo
     };
     let msg = Message::new(msg, user, lock.get_next_message_id(), None);
 
-    lock.send_message(&msg);
-    Json(Response(Ok(msg.id)))
+    let send = lock.send_message(&msg);
+    Json(Response(send))
 }
 
 #[get("/send_reply/<user_id>/<message_id>/<msg>")]
@@ -62,8 +68,8 @@ fn send_reply(user_id: usize, message_id: usize, msg: String, db: &State<SharedD
     };
     let msg = Message::new(msg, user, lock.get_next_message_id(), Some(message_id));
 
-    lock.send_message(&msg);
-    Json(Response(Ok(msg.id)))
+    let send = lock.send_message(&msg);
+    Json(Response(send))
 }
 
 #[get("/delete_message/<id>")]
@@ -82,7 +88,7 @@ fn get_user(id: usize, db: &State<SharedDB>) -> Json<Response<User, &'static str
     }
 }
 #[get("/get_user_by_name/<name>")]
-fn get_user_by_name(name: String, db: &State<SharedDB>) -> Json<Response<Vec<User>, &'static str>> {
+fn get_user_by_name(name: String, db: &State<SharedDB>) -> Json<Response<User, &'static str>> {
     let lock = db.sdb.lock().unwrap();
     match lock.get_user_by_name(name) {
         Some(n) => Json(Response(Ok(n))),
@@ -90,182 +96,12 @@ fn get_user_by_name(name: String, db: &State<SharedDB>) -> Json<Response<Vec<Use
     }
 }
 #[get("/create_user/<name>")]
-fn create_user(name: String, db: &State<SharedDB>) -> Json<Response<User, &'static str>> {
+fn create_user(name: String, db: &State<SharedDB>) -> Json<Response<(), &'static str>> {
     let mut lock = db.sdb.lock().unwrap();
 
     Json(Response(lock.create_user(name)))
 }
 
-struct SharedDB {
-    sdb: Mutex<Database>
-}
-
-struct Database {
-    usermap: HashMap<usize, User>,
-    messagemap: HashMap<usize, Message>,
-}
-impl Database {
-    fn get_message(&self, id: usize) -> Option<Message> {
-        match self.messagemap.get(&id) {
-            Some(n) => Some(n.to_owned()),
-            None => None,
-        }
-    }
-    fn get_message_id_list(&self, id_start: usize, id_end: usize) -> Vec<usize> {
-        let mut message_id_vec: Vec<usize> = vec![];
-
-        for x in id_start..=id_end {
-            match self.messagemap.get(&x) {
-                Some(_) => message_id_vec.push(x),
-                None => (),
-            }
-        }
-
-        return message_id_vec;
-    }
-    fn get_next_message_id(&self) -> usize {
-        self.messagemap.len()
-    }
-    fn get_message_newest_id(&self) -> Option<usize> {
-        let newest = self.get_next_message_id() as isize - 1;
-        let newest = if newest < 0 {0} else {newest as usize};
-        match self.messagemap.get(&newest) {
-            Some(_) => Some(newest),
-            None => None,
-        }
-    }
-
-    fn send_message(&mut self, msg: &Message) {
-        self.messagemap.insert(msg.id, msg.clone());
-        println!("{:?}", self.messagemap.get(&0));
-    }
-
-    fn delete_message(&mut self, id: usize) -> Result<&'static str, &'static str> {
-        let  msg = match self.messagemap.get_mut(&id) {
-            Some(n) => n,
-            None => return Err("Message not found"),
-        };
-
-        msg.delete();
-
-        Ok("Deleted")
-    }
-
-    fn get_user(&self, id: usize) -> Option<User> {
-        match self.usermap.get(&id) {
-            Some(n) => Some(n.to_owned()),
-            None => None
-        }
-    }
-    fn get_user_by_name(&self, name: String) -> Option<Vec<User>> {
-        let list: Vec<Option<User>> = self.usermap.values().map(|x| if x.username == name {Some(x.clone())} else {None}).collect();
-
-        let mut users = vec![];
-        for x in list {
-            match x {
-                Some(n) => users.push(n),
-                None => ()
-            }
-        }
-
-        if users.len() == 0 {
-            None
-        } else {
-            Some(users)
-        }
-    }
-
-    fn create_user(&mut self, name: String) -> Result<User, &'static str> {
-        let id = self.usermap.len();
-        let user = User::new(name.clone(), id);
-
-        match self.get_user_by_name(name) {
-            Some(_) => return Err("ID taken"),
-            None => (),
-        }
-
-        match self.usermap.get(&id) {
-            Some(_) => Err("ID taken"),
-            None => {self.usermap.insert(id, user.clone()); Ok(user)},
-        }
-    }
-
-    pub fn new() -> Database {
-        Database {
-            usermap: HashMap::new(),
-            messagemap: HashMap::new(),
-
-        }
-    }
-}
-
-#[derive(serde::Serialize, Clone, Debug)]
-struct Date {
-    date: u64,
-}
-impl Date {
-    pub fn now() -> Date {
-        Date{
-            date: SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs()
-        }
-    }
-}
-
-#[derive(serde::Serialize, Clone, Debug)]
-struct User {
-    username: String,
-    id: usize
-}
-impl User {
-    pub fn new(name: String, id: usize) -> User {
-        User{
-            username: name,
-            id: id
-        }
-    }
-}
-
-#[derive(serde::Serialize, Clone, Debug)]
-struct Message {
-    date: Date,
-    message: String,
-    sender: User,
-    id: usize,
-    reply_to: Option<usize>, // Message ID
-    deleted: bool,
-}
-impl Message {
-    pub fn new(msg: String, sender: User, id: usize, reply_to: Option<usize>) -> Message {
-        Message {
-            date: Date::now(),
-            sender: sender,
-            message: msg,
-            id: id,
-            reply_to: reply_to,
-            deleted: false,
-        }
-    }
-
-    fn delete(&mut self) {
-        self.message.clear();
-        self.deleted = true;
-    }
-}
-
-#[derive(serde::Serialize)]
-struct Info {
-    name: String,
-    users: usize,
-}
-impl Info {
-    pub fn get(db: std::sync::MutexGuard<Database>) -> Info {
-        Info{
-            name: String::from("Testing"),
-            users: db.usermap.len(),
-        }
-    }
-}
-
 #[get("/ping")]
 fn ping() -> Json<Response<&'static str, &'static str>> {
     Json(Response(Ok("pong")))
@@ -299,5 +135,5 @@ fn rocket() -> _ {
         delete_message,
     ])
     .mount("/", routes![api_index])
-    .manage(SharedDB{sdb: Mutex::new(Database::new())})
+    .manage(SharedDB{sdb: Mutex::new(database::Database::new())})
 }
-- 
cgit v1.2.3