Database limits, User fields/status

1 files changed, 79 insertions, 5 deletions

diff --git a/src/database.rs b/src/database.rs
index 0faa0d3..74d9c1a 100644
--- a/src/database.rs
+++ b/src/database.rs
@@ -168,21 +168,90 @@ impl Database {
         }
     }
 
+    pub fn set_user_field(&self, f: DataField, user: UID, data: String) -> Result<&'static str, &'static str> {
+        let query = format!("UPDATE users SET {}=:data WHERE id IS :id AND deleted IS false", f);
+        let statement = self.db.prepare(query).unwrap().into_iter()
+        .bind::<&[(_, sqlite::Value)]>(&[
+        (":id", user.into()),
+        (":data", data.into()),
+        ]);
+
+        let change_count = self.db.change_count();
+
+        for x in statement.unwrap() {
+            match x {
+                Ok(_) => (),
+                Err(n) => {
+                    match n.code.unwrap_or(0) {
+                        _ => return Err("Unknown error")
+                    }
+                },
+            }
+        }
+
+        if change_count > 0 {
+            Ok("Updated")
+        } else {
+            Err("Unabled to update")
+        }
+    }
+
+    pub fn set_user_status(&self, user: UID, status: Status) -> Result<&'static str, &'static str> {
+        let query = "UPDATE users SET status=:status WHERE id IS :id AND deleted IS false";
+        let statement = self.db.prepare(query).unwrap().into_iter()
+        .bind::<&[(_, sqlite::Value)]>(&[
+        (":id", user.into()),
+        (":status", i64::from(status).into()),
+        ]);
+
+        let change_count = self.db.change_count();
+
+        for x in statement.unwrap() {
+            match x {
+                Ok(_) => (),
+                Err(n) => {
+                    match n.code.unwrap_or(0) {
+                        _ => return Err("Unknown error")
+                    }
+                },
+            }
+        }
+
+        if change_count > 0 {
+            Ok("Updated")
+        } else {
+            Err("Unabled to update")
+        }
+    }
+
     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.into())]).unwrap();
 
         for row in statement.map(|row| row.unwrap()) {
 
-            let username = row.read::<&str, _>("username");
+            let username = row.read::<&str, _>("username").to_string();
             let id = row.read::<i64, _>("id").into();
+            let desc = match row.read::<Option<&str>, _>("desc") {
+                Some(n) => n.to_string(),
+                None => "".to_string(),
+            };
+            let displayname = match row.read::<Option<&str>, _>("displayname") {
+                Some(n) => n.to_string(),
+                None => "".to_string(),
+            };
+            let statustext = match row.read::<Option<&str>, _>("statustext") {
+                Some(n) => n.to_string(),
+                None => "".to_string(),
+            };
+            let status = row.read::<i64, _>("status");
             let deleted = if row.read::<i64, _>("deleted") > 0 {
                 true
             } else {
                 false
             };
 
-            return Some(User::construct(String::from(username), id, deleted))
+            return Some(User::construct(String::from(username), id, deleted, desc, displayname, statustext, status))
         }
 
         None
@@ -213,7 +282,7 @@ impl Database {
 
         let id: UID = self.get_user_count().into();
 
-        let query = "INSERT INTO users (id, username, deleted) VALUES (:id, :name, false)";
+        let query = "INSERT INTO users (id, username, deleted, status, displayname) VALUES (:id, :name, false, 0, :name)";
         let statement = self.db.prepare(query).unwrap().into_iter()
         .bind::<&[(_, sqlite::Value)]>(&[(":id", id.into()),(":name", name.into())]);
 
@@ -291,13 +360,18 @@ impl Database {
         };
 
         // Setup the db
-        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("PRAGMA foreign_keys = ON") {
+            Ok(_) => (),
+            Err(_) => panic!("Could not enable foreign_keys"),
+        };
+
+        let query = "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY NOT NULL, username TEXT UNIQUE NOT NULL CHECK (length(username) <= 20), deleted BOOL NOT NULL, displayname TEXT CHECK (length(displayname) <= 30), desc TEXT CHECK (length(desc) <= 500), statustext TEXT CHECK (length(statustext) <= 60), status INTEGER NOT NULL) WITHOUT ROWID";
         match db.execute(query) {
             Ok(_) => (),
             Err(n) => panic!("{n}"),
         }
 
-        let query = "CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY NOT NULL, sender INTEGER NOT NULL, date INTEGER NOT NULL, message TEXT, reply_to INTEGER, deleted BOOL NOT NULL) WITHOUT ROWID";
+        let query = "CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY NOT NULL, sender INTEGER NOT NULL, date INTEGER NOT NULL, message TEXT CHECK (length(message) <= 6000), reply_to INTEGER, deleted BOOL NOT NULL, FOREIGN KEY (sender) REFERENCES users(id), FOREIGN KEY (reply_to) REFERENCES messages(id)) WITHOUT ROWID";
         match db.execute(query) {
             Ok(_) => (),
             Err(n) => panic!("{n}"),