Add Exif storing and update to Metadata endpoint

src/database/mod.rs

@@ -4,7 +4,7 @@ use diesel::sqlite::SqliteConnection;
 use std::ops::DerefMut;
 use std::sync::{Arc, Mutex};
 
-use crate::database::models::{Favorite, InsertFavorite, InsertUser, User};
+use crate::database::models::{Favorite, ImageExif, InsertFavorite, InsertImageExif, InsertUser, User};
 
 pub mod models;
 pub mod schema;
@@ -181,3 +181,96 @@ impl FavoriteDao for SqliteFavoriteDao {
             .map_err(|_| DbError::new(DbErrorKind::QueryError))
     }
 }
+
+pub trait ExifDao: Sync + Send {
+    fn store_exif(&mut self, exif_data: InsertImageExif) -> Result<ImageExif, DbError>;
+    fn get_exif(&mut self, file_path: &str) -> Result<Option<ImageExif>, DbError>;
+    fn update_exif(&mut self, exif_data: InsertImageExif) -> Result<ImageExif, DbError>;
+    fn delete_exif(&mut self, file_path: &str) -> Result<(), DbError>;
+}
+
+pub struct SqliteExifDao {
+    connection: Arc<Mutex<SqliteConnection>>,
+}
+
+impl SqliteExifDao {
+    pub fn new() -> Self {
+        SqliteExifDao {
+            connection: Arc::new(Mutex::new(connect())),
+        }
+    }
+}
+
+impl ExifDao for SqliteExifDao {
+    fn store_exif(&mut self, exif_data: InsertImageExif) -> Result<ImageExif, DbError> {
+        use schema::image_exif::dsl::*;
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+
+        diesel::insert_into(image_exif)
+            .values(&exif_data)
+            .execute(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::InsertError))?;
+
+        image_exif
+            .filter(file_path.eq(&exif_data.file_path))
+            .first::<ImageExif>(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn get_exif(&mut self, path: &str) -> Result<Option<ImageExif>, DbError> {
+        use schema::image_exif::dsl::*;
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+
+        match image_exif
+            .filter(file_path.eq(path))
+            .first::<ImageExif>(connection.deref_mut())
+        {
+            Ok(exif) => Ok(Some(exif)),
+            Err(diesel::result::Error::NotFound) => Ok(None),
+            Err(_) => Err(DbError::new(DbErrorKind::QueryError)),
+        }
+    }
+
+    fn update_exif(&mut self, exif_data: InsertImageExif) -> Result<ImageExif, DbError> {
+        use schema::image_exif::dsl::*;
+
+        let mut connection = self.connection.lock().expect("Unable to get ExifDao");
+
+        diesel::update(image_exif.filter(file_path.eq(&exif_data.file_path)))
+            .set((
+                camera_make.eq(&exif_data.camera_make),
+                camera_model.eq(&exif_data.camera_model),
+                lens_model.eq(&exif_data.lens_model),
+                width.eq(&exif_data.width),
+                height.eq(&exif_data.height),
+                orientation.eq(&exif_data.orientation),
+                gps_latitude.eq(&exif_data.gps_latitude),
+                gps_longitude.eq(&exif_data.gps_longitude),
+                gps_altitude.eq(&exif_data.gps_altitude),
+                focal_length.eq(&exif_data.focal_length),
+                aperture.eq(&exif_data.aperture),
+                shutter_speed.eq(&exif_data.shutter_speed),
+                iso.eq(&exif_data.iso),
+                date_taken.eq(&exif_data.date_taken),
+                last_modified.eq(&exif_data.last_modified),
+            ))
+            .execute(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::InsertError))?;
+
+        image_exif
+            .filter(file_path.eq(&exif_data.file_path))
+            .first::<ImageExif>(connection.deref_mut())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+
+    fn delete_exif(&mut self, path: &str) -> Result<(), DbError> {
+        use schema::image_exif::dsl::*;
+
+        diesel::delete(image_exif.filter(file_path.eq(path)))
+            .execute(self.connection.lock().unwrap().deref_mut())
+            .map(|_| ())
+            .map_err(|_| DbError::new(DbErrorKind::QueryError))
+    }
+}