make database calls 1 conn

1 files changed, 159 insertions, 148 deletions

diff --git a/src/database/users.rs b/src/database/users.rs
index 6062ea8..9df69ee 100644
--- a/src/database/users.rs
+++ b/src/database/users.rs
@@ -2,169 +2,180 @@ use rusqlite::{OptionalExtension, Row};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tracing::instrument;
 
-use crate::{api::RegistrationRequet, database, types::user::User};
+use crate::{api::RegistrationRequet, 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, ())?;
+use super::Database;
 
-    let sql2 = "CREATE UNIQUE INDEX IF NOT EXISTS emails on users (email);";
-    conn.execute(sql2, ())?;
+impl Database {
+    pub fn init_users(&self) -> 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
+            );
+        ";
+        self.0.execute(sql, ())?;
 
-    let sql3 = "CREATE UNIQUE INDEX IF NOT EXISTS passwords on users (password);";
-    conn.execute(sql3, ())?;
+        let sql2 = "CREATE UNIQUE INDEX IF NOT EXISTS emails on users (email);";
+        self.0.execute(sql2, ())?;
 
-    Ok(())
-}
-
-pub 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 sql3 = "CREATE UNIQUE INDEX IF NOT EXISTS passwords on users (password);";
+        self.0.execute(sql3, ())?;
 
-    let password = if hide_password {
-        String::new()
-    } else {
-        password
-    };
+        Ok(())
+    }
 
-    Ok(User {
-        user_id,
-        firstname,
-        lastname,
-        email,
-        password,
-        gender,
-        date,
-        day,
-        month,
-        year,
-    })
-}
+    pub 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)?;
 
-#[instrument()]
-pub fn get_user_by_id(user_id: u64, hide_password: bool) -> Result<Option<User>, rusqlite::Error> {
-    tracing::trace!("Retrieving user by id");
-    let conn = database::connect()?;
-    let mut stmt = conn.prepare("SELECT * FROM users WHERE user_id = ?")?;
-    let row = stmt
-        .query_row([user_id], |row| {
-            let row = user_from_row(row, hide_password)?;
-            Ok(row)
-        })
-        .optional()?;
-    Ok(row)
-}
+        let password = if hide_password {
+            String::new()
+        } else {
+            password
+        };
 
-#[instrument()]
-pub fn get_user_by_email(
-    email: &str,
-    hide_password: bool,
-) -> Result<Option<User>, rusqlite::Error> {
-    tracing::trace!("Retrieving user by email");
-    let conn = database::connect()?;
-    let mut stmt = conn.prepare("SELECT * FROM users WHERE email = ?")?;
-    let row = stmt
-        .query_row([email], |row| {
-            let row = user_from_row(row, hide_password)?;
-            Ok(row)
+        Ok(User {
+            user_id,
+            firstname,
+            lastname,
+            email,
+            password,
+            gender,
+            date,
+            day,
+            month,
+            year,
         })
-        .optional()?;
-    Ok(row)
-}
+    }
 
-#[instrument()]
-pub fn get_user_by_password(
-    password: &str,
-    hide_password: bool,
-) -> Result<Option<User>, rusqlite::Error> {
-    tracing::trace!("Retrieving user by password");
-    let conn = database::connect()?;
-    let mut stmt = conn.prepare("SELECT * FROM users WHERE password = ?")?;
-    let row = stmt
-        .query_row([password], |row| {
-            let row = user_from_row(row, hide_password)?;
-            Ok(row)
-        })
-        .optional()?;
-    Ok(row)
-}
+    #[instrument(skip(self))]
+    pub fn get_user_by_id(
+        &self,
+        user_id: u64,
+        hide_password: bool,
+    ) -> Result<Option<User>, rusqlite::Error> {
+        tracing::trace!("Retrieving user by id");
+        let mut stmt = self.0.prepare("SELECT * FROM users WHERE user_id = ?")?;
+        let row = stmt
+            .query_row([user_id], |row| {
+                let row = Self::user_from_row(row, hide_password)?;
+                Ok(row)
+            })
+            .optional()?;
+        Ok(row)
+    }
 
-#[instrument()]
-pub fn get_user_page(page: u64, hide_password: bool) -> Result<Vec<User>, rusqlite::Error> {
-    tracing::trace!("Retrieving user page");
-    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| {
-        let row = user_from_row(row, hide_password)?;
+    #[instrument(skip(self))]
+    pub fn get_user_by_email(
+        &self,
+        email: &str,
+        hide_password: bool,
+    ) -> Result<Option<User>, rusqlite::Error> {
+        tracing::trace!("Retrieving user by email");
+        let mut stmt = self.0.prepare("SELECT * FROM users WHERE email = ?")?;
+        let row = stmt
+            .query_row([email], |row| {
+                let row = Self::user_from_row(row, hide_password)?;
+                Ok(row)
+            })
+            .optional()?;
         Ok(row)
-    })?;
-    Ok(row.into_iter().flatten().collect())
-}
+    }
 
-#[instrument()]
-pub fn get_all_users() -> Result<Vec<User>, rusqlite::Error> {
-    tracing::trace!("Retrieving user page");
-    let conn = database::connect()?;
-    let mut stmt = conn.prepare("SELECT * FROM users ORDER BY user_id DESC")?;
-    let row = stmt.query_map([], |row| {
-        let row = user_from_row(row, false)?;
+    #[instrument(skip(self))]
+    pub fn get_user_by_password(
+        &self,
+        password: &str,
+        hide_password: bool,
+    ) -> Result<Option<User>, rusqlite::Error> {
+        tracing::trace!("Retrieving user by password");
+        let mut stmt = self.0.prepare("SELECT * FROM users WHERE password = ?")?;
+        let row = stmt
+            .query_row([password], |row| {
+                let row = Self::user_from_row(row, hide_password)?;
+                Ok(row)
+            })
+            .optional()?;
         Ok(row)
-    })?;
-    Ok(row.into_iter().flatten().collect())
-}
+    }
 
-#[instrument()]
-pub fn add_user(request: RegistrationRequet) -> Result<User, rusqlite::Error> {
-    tracing::trace!("Adding new user");
-    let date = u64::try_from(
-        SystemTime::now()
-            .duration_since(UNIX_EPOCH)
-            .unwrap_or(Duration::ZERO)
-            .as_millis(),
-    )
-    .unwrap_or(0);
+    #[instrument(skip(self))]
+    pub fn get_user_page(
+        &self,
+        page: u64,
+        hide_password: bool,
+    ) -> Result<Vec<User>, rusqlite::Error> {
+        tracing::trace!("Retrieving user page");
+        let page_size = 5;
+        let mut stmt = self
+            .0
+            .prepare("SELECT * FROM users ORDER BY user_id DESC LIMIT ? OFFSET ?")?;
+        let row = stmt.query_map([page_size, page_size * page], |row| {
+            let row = Self::user_from_row(row, hide_password)?;
+            Ok(row)
+        })?;
+        Ok(row.into_iter().flatten().collect())
+    }
 
-    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(
-        (
-            request.firstname,
-            request.lastname,
-            request.email,
-            request.password,
-            request.gender,
-            date,
-            request.day,
-            request.month,
-            request.year,
-        ),
-        |row| {
-            let row = user_from_row(row, false)?;
+    #[instrument(skip(self))]
+    pub fn get_all_users(&self) -> Result<Vec<User>, rusqlite::Error> {
+        tracing::trace!("Retrieving user page");
+        let mut stmt = self
+            .0
+            .prepare("SELECT * FROM users ORDER BY user_id DESC")?;
+        let row = stmt.query_map([], |row| {
+            let row = Self::user_from_row(row, false)?;
             Ok(row)
-        },
-    )?;
-    Ok(user)
+        })?;
+        Ok(row.into_iter().flatten().collect())
+    }
+
+    #[instrument(skip(self))]
+    pub fn add_user(&self, request: RegistrationRequet) -> Result<User, rusqlite::Error> {
+        tracing::trace!("Adding new user");
+        let date = u64::try_from(
+            SystemTime::now()
+                .duration_since(UNIX_EPOCH)
+                .unwrap_or(Duration::ZERO)
+                .as_millis(),
+        )
+        .unwrap_or(0);
+
+        let mut stmt = self.0.prepare("INSERT INTO users (firstname, lastname, email, password, gender, date, day, month, year) VALUES(?,?,?,?,?,?,?,?,?) RETURNING *;")?;
+        let user = stmt.query_row(
+            (
+                request.firstname,
+                request.lastname,
+                request.email,
+                request.password,
+                request.gender,
+                date,
+                request.day,
+                request.month,
+                request.year,
+            ),
+            |row| {
+                let row = Self::user_from_row(row, false)?;
+                Ok(row)
+            },
+        )?;
+        Ok(user)
+    }
 }