Merge FS and DB library raw items.

backend/infrastructure/src/video/adapter.rs

@@ -6,6 +6,7 @@ use uuid::Uuid;
 use std::env;
 use std::fs;
 use std::fs::DirEntry;
+use std::io::{Error, ErrorKind};
 use lumiere_domain::video::model::video::VideoFormat::{AVI, MKV, MP4, WEBM};
 use crate::video::model::LibraryItemEntity;
 use crate::video::repository::LibraryItemSqliteRepository;
@@ -54,29 +55,32 @@ impl LibraryItemAdapter {
         Ok(library_raw_item)
     }
 
-    fn get_all_library_items_from_db(&self) -> Result<Vec<LibraryItem>, VideoError> {
-        self.repository.get_all_of_root_folder().map_err(|error| VideoError::FolderBrowsingTechnicalIssue)
-            .map(LibraryItemEntity::to_library_item)
+    fn get_all_library_items_from_db(&self) -> Result<Vec<LibraryRawItem>, Error> {
+        self.repository.get_all_of_root_folder().map_err(|error| Error::new(ErrorKind::Other, "Unable to retrieve the library items of root folder from database."))
+            .and_then(|entities| entities.into_iter()
+                .map(LibraryItemEntity::to_library_raw_item)
+                .collect::<Result<Vec<LibraryRawItem>, _>>())
     }
 
     fn merge_item_lists(file_system_items: Vec<LibraryRawItem>, db_items: Vec<LibraryRawItem>) -> Vec<LibraryRawItem> {
-        let file_system_items_which_are_not_in_database: Vec<LibraryRawItem> = file_system_items.into_iter()
+        let file_system_items_which_are_not_in_database = file_system_items.into_iter()
             .filter(|file_system_item| !Self::does_item_belong_to_db_items(&db_items, &file_system_item))
-            .collect();
+            .collect::<Vec<LibraryRawItem>>();
 
         db_items.into_iter().chain(file_system_items_which_are_not_in_database).collect()
     }
 
     fn does_item_belong_to_db_items(database_items: &Vec<LibraryRawItem>, file_system_item: &LibraryRawItem) -> bool {
         database_items.iter()
-            .any(|database_item| database_item.id == file_system_item.id)
+                .any(|database_item| database_item.id == file_system_item.id)
     }
 }
 
 impl VideoPort for LibraryItemAdapter {
     fn list_root_folder(&self) -> Result<Vec<LibraryRawItem>, VideoError> {
         let file_system_items = self.get_root_folder_read_library_items()?;
-        let db_items = self.get_all_library_items_from_db()?;
+        let db_items = self.get_all_library_items_from_db()
+            .map_err(|_| VideoError::FileReadingTechnicalIssue)?;
 
         let merged = Self::merge_item_lists(file_system_items, db_items);
 

backend/infrastructure/src/video/mod.rs

@@ -1,4 +1,4 @@
 pub mod adapter;
 pub mod model;
 pub mod video_format_detector;
-mod repository;
+pub mod repository;

backend/infrastructure/src/video/model.rs

@@ -1,7 +1,7 @@
 use std::fs::File;
 use std::io::{Error, ErrorKind};
 use uuid::Uuid;
-use lumiere_domain::video::model::library_item::{LibraryItem, LibraryItemType};
+use lumiere_domain::video::model::library_item::{LibraryItem, LibraryItemType, LibraryRawItem};
 
 pub struct TokioVideoFile {
     pub file: File
@@ -50,9 +50,9 @@ impl LibraryItemEntity {
         }
     }
 
-    pub(crate) fn to_library_item(&self) -> Result<LibraryItem, Error> {
-        let library_item = LibraryItem {
-            id: self.id.clone(),
+    pub(crate) fn to_library_raw_item(self) -> Result<LibraryRawItem, Error> {
+        let library_item = LibraryRawItem {
+            id: Some(self.id.clone()),
             name: self.name.clone(),
             r#type: Self::map_type_from_i8(self.r#type)?
         };