i did things

4 files changed, 231 insertions, 0 deletions

diff --git a/src/database/mod.rs b/src/database/mod.rs
new file mode 100644
index 0000000..7227074
--- /dev/null
+++ b/src/database/mod.rs
@@ -0,0 +1,16 @@
+use rusqlite::Result;
+
+pub mod posts;
+pub mod users;
+pub mod sessions;
+
+pub fn connect() -> Result<rusqlite::Connection, rusqlite::Error> {
+    return rusqlite::Connection::open("xssbook.db");
+}
+
+pub fn init() -> Result<()> {
+    users::init()?;
+    posts::init()?;
+    sessions::init()?;
+    Ok(())
+}
\ No newline at end of file
diff --git a/src/database/posts.rs b/src/database/posts.rs
new file mode 100644
index 0000000..77d2387
--- /dev/null
+++ b/src/database/posts.rs
@@ -0,0 +1,94 @@
+use std::collections::HashSet;
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use rusqlite::{OptionalExtension, Row};
+
+use crate::types::post::Post;
+use crate::database;
+
+pub fn init() -> Result<(), rusqlite::Error> {
+    let sql = "
+        CREATE TABLE IF NOT EXISTS posts (
+            post_id     INTEGER PRIMARY KEY AUTOINCREMENT,
+            user_id     INTEGER NOT NULL,
+            content     TEXT NOT NULL,
+            likes       TEXT NOT NULL,
+            comments    TEXT NOT NULL,
+            date        INTEGER NOT NULL,
+            FOREIGN KEY(user_id) REFERENCES users(user_id)
+        );
+    ";
+    let conn = database::connect()?;
+    conn.execute(sql, ())?;
+    Ok(())
+}
+
+fn post_from_row(row: &Row) -> Result<Post, rusqlite::Error> {
+    let post_id = row.get(0)?;
+    let user_id = row.get(1)?;
+    let content = row.get(2)?;
+    let likes_json: String = row.get(3)?;
+    let comments_json: String = row.get(4)?;
+    let date = row.get(5)?;
+
+    let Ok(likes) = serde_json::from_str(&likes_json) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+
+    let Ok(comments) = serde_json::from_str(&comments_json) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+
+    Ok(Post{post_id, user_id, content, likes, comments, date})
+}
+
+pub fn get_post(post_id: u64) -> Result<Option<Post>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM posts WHERE post_id = ?")?;
+    let row = stmt.query_row([post_id], |row| Ok(post_from_row(row)?)).optional()?;
+    Ok(row)
+}
+
+pub fn get_post_page(page: u64) -> Result<Vec<Post>, rusqlite::Error> {
+    let page_size = 10;
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM posts ORDER BY post_id DESC LIMIT ? OFFSET ?")?;
+    let row = stmt.query_map([page_size, page_size * page], |row| Ok(post_from_row(row)?))?;
+    Ok(row.into_iter().flatten().collect())
+}
+
+pub fn get_users_posts(user_id: u64) -> Result<Vec<Post>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM posts WHERE user_id = ? ORDER BY post_id DESC")?;
+    let row = stmt.query_map([user_id], |row| Ok(post_from_row(row)?))?;
+    Ok(row.into_iter().flatten().collect())
+}
+
+pub fn add_post(user_id: u64, content: &str) -> Result<Post, rusqlite::Error> {
+    let likes: HashSet<u64> = HashSet::new();
+    let comments: Vec<(u64, String)> = Vec::new();
+    let Ok(likes_json) = serde_json::to_string(&likes) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+    let Ok(comments_json) = serde_json::to_string(&comments) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+    let date = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("INSERT INTO posts (user_id, content, likes, comments, date) VALUES(?,?,?,?,?) RETURNING *;")?;
+    let post = stmt.query_row((user_id, content, likes_json, comments_json, date), |row| Ok(post_from_row(row)?))?;
+    Ok(post)
+}
+
+pub fn update_post(post_id: u64, likes: &HashSet<u64>, comments: &Vec<(u64, String)>) -> Result<(), rusqlite::Error> {
+    let Ok(likes_json) = serde_json::to_string(&likes) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+    let Ok(comments_json) = serde_json::to_string(&comments) else {
+        return Err(rusqlite::Error::InvalidQuery)
+    };
+    let conn = database::connect()?;
+    let sql = "UPDATE posts SET likes = ?, comments = ? WHERE post_id = ?";
+    conn.execute(sql, (likes_json, comments_json, post_id))?;
+    Ok(())
+}
\ No newline at end of file
diff --git a/src/database/sessions.rs b/src/database/sessions.rs
new file mode 100644
index 0000000..7866d76
--- /dev/null
+++ b/src/database/sessions.rs
@@ -0,0 +1,42 @@
+use rusqlite::OptionalExtension;
+
+use crate::{database, types::session::Session};
+
+pub fn init() -> Result<(), rusqlite::Error> {
+    let sql = "
+        CREATE TABLE IF NOT EXISTS sessions (
+            user_id        INTEGER PRIMARY KEY NOT NULL,
+            token       TEXT NOT NULL,  
+            FOREIGN KEY(user_id) REFERENCES users(user_id)
+        );
+    ";
+    let conn = database::connect()?;
+    conn.execute(sql, ())?;
+    Ok(())
+}
+
+pub fn get_session(token: &str) -> Result<Option<Session>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM sessions WHERE token = ?")?;
+    let row = stmt.query_row([token], |row| {
+        Ok(Session {
+            user_id: row.get(0)?,
+            token: row.get(1)?,
+        })
+    }).optional()?;
+    Ok(row)
+}
+
+pub fn set_session(user_id: u64, token: &str) -> Result<(), Box<dyn std::error::Error>> {
+    let conn = database::connect()?;
+    let sql = "INSERT OR REPLACE INTO sessions (user_id, token) VALUES (?, ?);";
+    conn.execute(sql, (user_id, token))?;
+    Ok(())
+}
+
+pub fn delete_session(user_id: u64) -> Result<(), Box<dyn std::error::Error>> {
+    let conn = database::connect()?;
+    let sql = "DELETE FROM sessions WHERE user_id = ?;";
+    conn.execute(sql, [user_id])?;
+    Ok(())
+}
\ No newline at end of file
diff --git a/src/database/users.rs b/src/database/users.rs
new file mode 100644
index 0000000..2618dce
--- /dev/null
+++ b/src/database/users.rs
@@ -0,0 +1,79 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+use rusqlite::{OptionalExtension, Row};
+
+use crate::{database, types::user::User};
+
+pub fn init() -> Result<(), rusqlite::Error> {
+    let sql = "
+        CREATE TABLE IF NOT EXISTS users (
+            user_id     INTEGER PRIMARY KEY AUTOINCREMENT,
+            firstname   VARCHAR(20) NOT NULL,
+            lastname    VARCHAR(20) NOT NULL,
+            email       VARCHAR(50) NOT NULL,
+            password    VARCHAR(50) NOT NULL,
+            gender      VARCHAR(100) NOT NULL,
+            date        BIGINT NOT NULL,
+            day         TINYINT NOT NULL,
+            month       TINYINT NOT NULL,
+            year        INTEGER NOT NULL
+        );
+    ";
+    let conn = database::connect()?;
+    conn.execute(sql, ())?;
+    Ok(())
+}
+
+fn user_from_row(row: &Row, hide_password: bool) -> Result<User, rusqlite::Error> {
+    let user_id = row.get(0)?;
+    let firstname = row.get(1)?;
+    let lastname = row.get(2)?;
+    let email = row.get(3)?;
+    let password = row.get(4)?;
+    let gender = row.get(5)?;
+    let date = row.get(6)?;
+    let day = row.get(7)?;
+    let month = row.get(8)?;
+    let year = row.get(9)?;
+
+    let password = if hide_password { "".to_string() } else { password };
+
+    Ok(User{user_id, firstname, lastname, email, password, gender,date, day, month, year})
+}
+
+pub fn get_user_by_id(user_id: u64, hide_password: bool) -> Result<Option<User>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM users WHERE user_id = ?")?;
+    let row = stmt.query_row([user_id], |row| Ok(user_from_row(row, hide_password)?)).optional()?;
+    Ok(row)
+}
+
+pub fn get_user_by_email(email: &str, hide_password: bool) -> Result<Option<User>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM users WHERE email = ?")?;
+    let row = stmt.query_row([email], |row| Ok(user_from_row(row, hide_password)?)).optional()?;
+    Ok(row)
+}
+
+pub fn get_user_by_password(password: &str, hide_password: bool) -> Result<Option<User>, rusqlite::Error> {
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM users WHERE password = ?")?;
+    let row = stmt.query_row([password], |row| Ok(user_from_row(row, hide_password)?)).optional()?;
+    Ok(row)
+}
+
+pub fn get_user_page(page: u64, hide_password: bool) -> Result<Vec<User>, rusqlite::Error> {
+    let page_size = 5;
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("SELECT * FROM users ORDER BY user_id DESC LIMIT ? OFFSET ?")?;
+    let row = stmt.query_map([page_size, page_size * page], |row| Ok(user_from_row(row, hide_password)?))?;
+    Ok(row.into_iter().flatten().collect())
+}
+
+pub fn add_user(firstname: &str, lastname: &str, email: &str, password: &str, gender: &str, day: u8, month: u8, year: u32) -> Result<User, rusqlite::Error> {
+    let date = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
+
+    let conn = database::connect()?;
+    let mut stmt = conn.prepare("INSERT INTO users (firstname, lastname, email, password, gender, date, day, month, year) VALUES(?,?,?,?,?,?,?,?,?) RETURNING *;")?;
+    let user = stmt.query_row((firstname, lastname, email, password, gender, date, day, month, year), |row| Ok(user_from_row(row, false)?))?;
+    Ok(user)
+}
\ No newline at end of file