FavoritesDao for querying, adding and removing favorites

src/database/mod.rs

@@ -1,6 +1,10 @@
 use bcrypt::{hash, verify, DEFAULT_COST};
 use diesel::prelude::*;
 use diesel::sqlite::SqliteConnection;
+use std::{
+    ops::Deref,
+    sync::{Arc, Mutex},
+};
 
 use crate::database::models::{Favorite, InsertFavorite, InsertUser, User};
 
@@ -85,25 +89,87 @@ fn connect() -> SqliteConnection {
     SqliteConnection::establish(&db_url).expect("Error connecting to DB")
 }
 
-pub fn add_favorite(user_id: i32, favorite_path: String) {
-    use schema::favorites::dsl::*;
-
-    let connection = connect();
-    diesel::insert_into(favorites)
-        .values(InsertFavorite {
-            userid: &user_id,
-            path: &favorite_path,
-        })
-        .execute(&connection)
-        .unwrap();
+#[derive(Debug)]
+pub struct DbError {
+    pub kind: DbErrorKind,
 }
 
-pub fn get_favorites(user_id: i32) -> diesel::QueryResult<Vec<Favorite>> {
-    use schema::favorites::dsl::*;
+impl DbError {
+    fn new(kind: DbErrorKind) -> Self {
+        DbError { kind }
+    }
 
-    favorites
-        .filter(userid.eq(user_id))
-        .load::<Favorite>(&connect())
+    fn exists() -> Self {
+        DbError::new(DbErrorKind::AlreadyExists)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum DbErrorKind {
+    AlreadyExists,
+    InsertError,
+    QueryError,
+}
+
+pub trait FavoriteDao: Sync + Send {
+    fn add_favorite(&self, user_id: i32, favorite_path: &str) -> Result<usize, DbError>;
+    fn remove_favorite(&self, user_id: i32, favorite_path: String);
+    fn get_favorites(&self, user_id: i32) -> Result<Vec<Favorite>, DbError>;
+}
+
+pub struct SqliteFavoriteDao {
+    connection: Arc<Mutex<SqliteConnection>>,
+}
+
+impl SqliteFavoriteDao {
+    pub fn new() -> Self {
+        SqliteFavoriteDao {
+            connection: Arc::new(Mutex::new(connect())),
+        }
+    }
+}
+
+impl FavoriteDao for SqliteFavoriteDao {
+    fn add_favorite(&self, user_id: i32, favorite_path: &str) -> Result<usize, DbError> {
+        use schema::favorites::dsl::*;
+
+        let connection = self.connection.lock().unwrap();
+        let connection = connection.deref();
+
+        if favorites
+            .filter(userid.eq(user_id).and(path.eq(&favorite_path)))
+            .first::<Favorite>(connection)
+            .is_err()
+        {
+            diesel::insert_into(favorites)
+                .values(InsertFavorite {
+                    userid: &user_id,
+                    path: &favorite_path,
+                })
+                .execute(connection)
+                .map_err(|_| DbError::new(DbErrorKind::InsertError))
+        } else {
+            Err(DbError::exists())
+        }
+    }
+
+    fn remove_favorite(&self, user_id: i32, favorite_path: String) {
+        use schema::favorites::dsl::*;
+
+        diesel::delete(favorites)
+            .filter(userid.eq(user_id).and(path.eq(favorite_path)))
+            .execute(self.connection.lock().unwrap().deref())
+            .unwrap();
+    }
+
+    fn get_favorites(&self, user_id: i32) -> Result<Vec<Favorite>, DbError> {
+        use schema::favorites::dsl::*;
+
+        favorites
+            .filter(userid.eq(user_id))
+            .load::<Favorite>(self.connection.lock().unwrap().deref())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
 }
 
 #[cfg(test)]