POST and more

1 files changed, 43 insertions, 60 deletions

diff --git a/src/database.rs b/src/database.rs
index af7de68..84c402f 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -1,8 +1,7 @@
 pub mod r#types;
 
 use sqlite::Connection;
-
-use types::{Message, User};
+use super::*;
 
 
 pub struct Database {
@@ -18,24 +17,20 @@ impl Database {
             let msg = row.read::<&str, _>("message");
             let reply_to = row.read::<Option<i64>, _>("reply_to");
             let reply_to = match reply_to {
-                Some(n) => Some(self.i64_into_usize(n)),
+                Some(n) => Some(n.into()),
                 None => None
             };
 
-            let date = row.read::<i64, _>("date");
-            let date = types::Date::new(date);
-
+            let date = row.read::<i64, _>("date").into();
             let deleted = row.read::<i64, _>("deleted");
-            let deleted = match deleted {
-                0 => false,
-                _ => true,
+            let deleted = if deleted < 0 {
+                false
+            } else {
+                true 
             };
 
-            let sender = row.read::<i64, _>("sender");
-            let sender = self.get_user(sender as usize).unwrap();
-
-            let id = row.read::<i64, _>("id");
-            let id = self.i64_into_usize(id);
+            let sender = row.read::<i64, _>("sender").into();
+            let id = row.read::<i64, _>("id").into();
 
 
             let msg = Message::construct(String::from(msg), sender, id, reply_to, date, deleted);
@@ -44,49 +39,45 @@ impl Database {
 
         None
     }
-    pub fn get_message_id_list(&self, id_start: usize, id_end: usize) -> Vec<usize> {
-        let query = "SELECT id FROM messages WHERE deleted is false AND id BETWEEN :id_start AND :id_end";
+    pub fn get_message_id_list(&self, id_start: UID, id_end: UID) -> Vec<UID> {
+        let query = "SELECT id FROM messages WHERE id BETWEEN :id_start AND :id_end";
         let statement = self.db.prepare(query).unwrap().into_iter().bind::<&[(_, sqlite::Value)]>(&[
-            (":id_start", (id_start as i64).into()),
-            (":id_end", (id_end as i64).into()),
+            (":id_start", id_start.into()),
+            (":id_end", id_end.into()),
             ]).unwrap();
 
 
-        let mut message_id_vec: Vec<usize> = vec![];
+        let mut message_id_vec: Vec<UID> = vec![];
         for row in statement.map(|row| row.unwrap()) {
-            let id = row.read::<i64, _>("id");
-            let id = self.i64_into_usize(id);
+            let id = row.read::<i64, _>("id").into();
 
             message_id_vec.push(id);
         }
 
         return message_id_vec;
     }
-    pub fn get_next_message_id(&self) -> usize {
-        self.get_table_length("messages") as usize
+    pub fn get_next_message_id(&self) -> UID {
+        UID::from(self.get_table_length("messages"))
     }
-    pub fn get_message_newest_id(&self) -> Option<usize> {
-        match self.get_table_length("messages") as usize {
+    pub fn get_message_newest_id(&self) -> Option<UID> {
+        match self.get_table_length("messages") {
             0 => None,
-            n => Some(n - 1),
+            n => Some(UID::new(n - 1)),
         }
-
     }
 
-    pub fn send_message(&mut self, msg: &Message) -> Result<usize, &'static str> {
-        let id = msg.id();
-
+    pub fn send_message(&mut self, msg: &Message) -> Result<UID, &'static str> {
         let query = "INSERT INTO messages (date, sender, message, id, reply_to, deleted) VALUES (:date, :sender, :message, :id, :reply_to, :deleted)";
         let statement = self.db.prepare(query).unwrap().into_iter()
         .bind::<&[(_, sqlite::Value)]>(&[
-            (":date", msg.date_as_i64().into()),
-            (":sender", msg.user_id().into()),
+            (":date", msg.date().into()),
+            (":sender", msg.sender().into()),
             (":message", msg.message().into()),
             (":reply_to", match msg.reply_to() {
                 Some(n) => n.into(),
                 None => ().into()
             }),
-            (":id", (id as i64).into()),
+            (":id", msg.id().into()),
             (":deleted", 0.into()),
             ]);
 
@@ -101,16 +92,16 @@ impl Database {
             }
         }
 
-        Ok(id)
+        Ok(msg.id())
     }
 
-    pub fn delete_message(&mut self, id: usize) -> Result<&'static str, &'static str> {
+    pub fn delete_message(&mut self, id: UID) -> Result<&'static str, &'static str> {
         let query = "UPDATE messages SET message=:message, deleted=:deleted WHERE id IS :id AND deleted IS false";
         let statement = self.db.prepare(query).unwrap().into_iter()
             .bind::<&[(_, sqlite::Value)]>(&[
             (":message", "".into()),
             (":deleted", 1.into()),
-            (":id", (id as i64).into()),
+            (":id", id.into()),
             ]);
 
         let change_count = self.db.change_count();
@@ -133,16 +124,14 @@ impl Database {
         }
     }
 
-    pub fn get_user(&self, id: usize) -> Option<User> {
+    pub fn get_user(&self, id: UID) -> Option<User> {
         let query = "SELECT * FROM users WHERE id IS :id";
-        let statement = self.db.prepare(query).unwrap().into_iter().bind::<&[(_, sqlite::Value)]>(&[(":id", (id as i64).into())]).unwrap();
+        let statement = self.db.prepare(query).unwrap().into_iter().bind::<&[(_, sqlite::Value)]>(&[(":id", id.into())]).unwrap();
 
         for row in statement.map(|row| row.unwrap()) {
 
             let username = row.read::<&str, _>("username");
-            let id = row.read::<i64, _>("id");
-
-            let id = self.i64_into_usize(id);
+            let id = row.read::<i64, _>("id").into();
 
             return Some(User::new(String::from(username), id))
         }
@@ -155,9 +144,7 @@ impl Database {
 
         for row in statement.map(|row| row.unwrap()) {
             let username = row.read::<&str, _>("username");
-            let id = row.read::<i64, _>("id");
-
-            let id = self.i64_into_usize(id);
+            let id = row.read::<i64, _>("id").into();
 
             return Some(User::new(String::from(username), id))
         }
@@ -165,12 +152,12 @@ impl Database {
         None
     }
 
-    pub fn create_user(&mut self, name: String) -> Result<usize, &'static str> {
-        let id = self.get_user_count();
+    pub fn create_user(&mut self, name: String) -> Result<UID, &'static str> {
+        let id: UID = self.get_user_count().into();
 
         let query = "INSERT INTO users (id, username) VALUES (:id, :name)";
         let statement = self.db.prepare(query).unwrap().into_iter()
-        .bind::<&[(_, sqlite::Value)]>(&[(":id", (id as i64).into()),(":name", name.into())]);
+        .bind::<&[(_, sqlite::Value)]>(&[(":id", id.into()),(":name", name.into())]);
 
         for x in statement.unwrap() {
             match x {
@@ -187,33 +174,29 @@ impl Database {
         Ok(id)
     }
 
-    pub fn get_user_count(&self) -> usize {
+    pub fn get_user_count(&self) -> u64 {
         self.get_table_length("users")
     }
 
-    fn get_table_length(&self, table: &'static str) -> usize {
+    fn get_table_length(&self, table: &'static str) -> u64 {
         let query = format!("SELECT COUNT(*) FROM {}", table);
         let statement = self.db.prepare(query).unwrap().into_iter();
 
         for row in statement.map(|row| row.unwrap()) {
             let c = row.read::<i64, _>("COUNT(*)");
-            
-            let c = self.i64_into_usize(c);
-            
+
+            let c = if c < 0 {
+                0
+            } else {
+                c as u64
+            };
+                        
             return c;
         }
 
         0
     }
 
-    fn i64_into_usize(&self, i: i64) -> usize {
-        if i < 0 {
-            0
-        } else {
-            i as usize
-        }
-    }
-
     pub fn new() -> Database {
         let db = match Connection::open("db.sqlite") {
             Ok(n) => n,