From 7bbc871e3402fdedec8f07c8969a8877b87fae18 Mon Sep 17 00:00:00 2001
From: curly <curlybryce@protonmail.com>
Date: Thu, 9 Feb 2023 09:27:58 -0700
Subject: message_list, delete_user, limits

---
 src/database.rs | 90 +++++++++++++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 85 insertions(+), 5 deletions(-)

(limited to 'src/database.rs')

diff --git a/src/database.rs b/src/database.rs
index 84c402f..0671594 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -13,7 +13,6 @@ impl Database {
         let statement = self.db.prepare(query).unwrap().into_iter().bind((":id", id as i64)).unwrap();
 
         for row in statement.map(|row| row.unwrap()) {
-
             let msg = row.read::<&str, _>("message");
             let reply_to = row.read::<Option<i64>, _>("reply_to");
             let reply_to = match reply_to {
@@ -23,7 +22,7 @@ impl Database {
 
             let date = row.read::<i64, _>("date").into();
             let deleted = row.read::<i64, _>("deleted");
-            let deleted = if deleted < 0 {
+            let deleted = if deleted < 1 {
                 false
             } else {
                 true 
@@ -66,7 +65,54 @@ impl Database {
         }
     }
 
+    pub fn get_message_list(&self, id_start: UID, id_end: UID) -> Vec<Message> {
+        let query = "SELECT * 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.into()),
+            (":id_end", id_end.into()),
+            ]).unwrap();
+
+
+        let mut message_id_vec: Vec<Message> = vec![];
+        for row in statement.map(|row| row.unwrap()) {
+            let msg = row.read::<&str, _>("message");
+            let reply_to = row.read::<Option<i64>, _>("reply_to");
+            let reply_to = match reply_to {
+                Some(n) => Some(n.into()),
+                None => None
+            };
+
+            let date = row.read::<i64, _>("date").into();
+            let deleted = row.read::<i64, _>("deleted");
+            let deleted = if deleted < 1 {
+                false
+            } else {
+                true 
+            };
+
+            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);
+
+
+            message_id_vec.push(msg);
+        }
+
+        return message_id_vec;
+    }
+
     pub fn send_message(&mut self, msg: &Message) -> Result<UID, &'static str> {
+        // Check if user exists
+        match self.get_user(msg.sender()) {
+            Some(n) => match n.deleted() {
+                true => return Err("User deleted"),
+                false => ()
+            },
+            None => return Err("User not found"),
+        }
+
         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)]>(&[
@@ -132,8 +178,13 @@ impl Database {
 
             let username = row.read::<&str, _>("username");
             let id = row.read::<i64, _>("id").into();
+            let deleted = if row.read::<i64, _>("deleted") > 0 {
+                true
+            } else {
+                false
+            };
 
-            return Some(User::new(String::from(username), id))
+            return Some(User::construct(String::from(username), id, deleted))
         }
 
         None
@@ -155,7 +206,7 @@ impl Database {
     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 query = "INSERT INTO users (id, username, deleted) VALUES (:id, :name, false)";
         let statement = self.db.prepare(query).unwrap().into_iter()
         .bind::<&[(_, sqlite::Value)]>(&[(":id", id.into()),(":name", name.into())]);
 
@@ -174,6 +225,35 @@ impl Database {
         Ok(id)
     }
 
+    pub fn delete_user(&mut self, id: UID) -> Result<&'static str, String> {
+        let query = "UPDATE users SET username=:username, deleted=:deleted WHERE id IS :id AND deleted IS false";
+        let statement = self.db.prepare(query).unwrap().into_iter()
+            .bind::<&[(_, sqlite::Value)]>(&[
+            (":username", "deleted".into()),
+            (":deleted", 1.into()),
+            (":id", id.into()),
+            ]);
+
+        let change_count = self.db.change_count();
+
+        for x in statement.unwrap() {
+            match x {
+                Ok(_) => (),
+                Err(n) => {
+                    match n.code.unwrap_or(0) {
+                        n => return Err(format!("Unknown Error: {}", n))
+                    }
+                },
+            }
+        }
+
+        if change_count > 0 {
+            Ok("Deleted")
+        } else {
+            Err("Unabled to delete".to_string())
+        }
+    }
+
     pub fn get_user_count(&self) -> u64 {
         self.get_table_length("users")
     }
@@ -204,7 +284,7 @@ impl Database {
         };
 
         // Setup the db
-        let query = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY NOT NULL, username UNIQUE NOT NULL) WITHOUT ROWID";
+        let query = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY NOT NULL, username UNIQUE NOT NULL, deleted BOOL NOT NULL) WITHOUT ROWID";
         match db.execute(query) {
             Ok(_) => (),
             Err(n) => panic!("{n}"),
-- 
cgit v1.2.3