Refacto get_root_folder_read_library_items method.

backend/domain/src/video/model/library_item.rs

@@ -21,6 +21,10 @@ pub struct LibraryRawItem {
     pub r#type: LibraryItemType,
 }
 impl LibraryRawItem {
+    pub fn new(id: Option<Uuid>, name: String, r#type: LibraryItemType) -> Self {
+        Self { id, name, r#type }
+    }
+
     pub fn map_to_library_item(&self) -> LibraryItem {
         LibraryItem {
             id: self.id.unwrap_or(Uuid::new_v4()),

backend/infrastructure/src/video/adapter.rs

@@ -1,10 +1,11 @@
 use lumiere_domain::video::error::VideoError;
-use lumiere_domain::video::model::library_item::{LibraryItem, LibraryRawItem};
+use lumiere_domain::video::model::library_item::{LibraryItem, LibraryItemType, LibraryRawItem};
 use lumiere_domain::video::model::video::Video;
 use lumiere_domain::video::port::VideoPort;
 use uuid::Uuid;
 use std::env;
 use std::fs;
+use std::fs::DirEntry;
 
 #[derive(Clone)]
 pub struct VideoAdapter {
@@ -17,38 +18,28 @@ impl VideoAdapter {
     }
 
     fn get_root_folder_read_library_items(&self) -> Result<Vec<LibraryRawItem>, VideoError> {
-        // Get the root_folder path from environment variable
         let root_folder = env::var("ROOT_FOLDER").map_err(|_| VideoError::FolderBrowsingTechnicalIssue)?;
 
-        // List all elements inside this folder on the file system
-        let entries = fs::read_dir(root_folder)
-            .map_err(|e| VideoError::FolderBrowsingTechnicalIssue)?;
+        let root_folder_files = fs::read_dir(root_folder)
+            .map_err(|_| VideoError::FolderBrowsingTechnicalIssue)?;
 
-        // Map all those elements into ReadLibraryItem objects
-        let mut items: Vec<LibraryRawItem> = Vec::new();
-        for entry in entries {
-            let entry = entry.map_err(|e| VideoError::FolderBrowsingTechnicalIssue)?;
-            let path = entry.path();
+        root_folder_files.into_iter()
+            .map(|file_entry|
+                file_entry.map_err(|_| VideoError::FolderBrowsingTechnicalIssue)
+                    .and_then(Self::map_file_into_library_raw_item)
+            )
+            .collect()
+    }
 
-            // Determine if it's a file or directory
-            let is_dir = path.is_dir();
-            let item_type = if is_dir {
-                lumiere_domain::video::model::library_item::LibraryItemType::FOLDER
-            } else {
-                lumiere_domain::video::model::library_item::LibraryItemType::VIDEO
-            };
+    fn map_file_into_library_raw_item(file: DirEntry) -> Result<LibraryRawItem, VideoError> {
+        let item_type = if file.path().is_dir() {
+            LibraryItemType::FOLDER
+        } else {
+            LibraryItemType::VIDEO
+        };
 
-            // Create ReadLibraryItem with None for ID (will be generated later)
-            let item = LibraryRawItem {
-                id: None,
-                name: entry.file_name().to_string_lossy().into_owned(),
-                r#type: item_type,
-            };
-            
-            items.push(item);
-        }
-        
-        Ok(items)
+        let library_raw_item = LibraryRawItem::new(None, file.file_name().to_string_lossy().into_owned(), item_type);
+        Ok(library_raw_item)
     }
 
     fn get_all_library_items_from_db(&self) -> Result<Vec<LibraryRawItem>, VideoError> {