Refactor media source path configuration

Introduced support for named media source paths with optional metadata like original path and extension. Added backward compatibility for legacy configuration and updated Helm chart values and documentation to reflect the new structure.

Author: devclef

charts/shoebox/README.md

@@ -64,7 +64,7 @@ The following table lists the configurable parameters of the Shoebox chart and t
 | `config.serverHost` | Host to bind the server | `0.0.0.0` |
 | `config.serverPort` | Port to bind the server | `3000` |
 | `config.databaseUrl` | Database URL (SQLite) | `sqlite:/app/data/videos.db` |
-| `config.mediaSourcePaths` | Paths to scan for videos | `/mnt/videos` |
+| `config.mediaSourcePaths` | Paths to scan for videos (supports named sections, see docs) | `/mnt/videos` |
 | `config.thumbnailPath` | Path to store thumbnails | `/app/thumbnails` |
 | `config.exportBasePath` | Path for exported files | `/app/exports` |
 | `config.rustLog` | Rust log level | `info` |

charts/shoebox/values.yaml

@@ -92,7 +92,17 @@ config:
   serverHost: "0.0.0.0"
   serverPort: 3000
   databaseUrl: "sqlite:/app/data/videos.db"
-  mediaSourcePaths: "/mnt/videos"
+  # Media source paths configuration
+  # You can configure multiple media sources with different settings
+  mediaSourcePaths:
+    sources:
+      - name: bmpcc
+        path: /mnt/videos
+        originalPath: /home/user/videos
+        originalExtension: mp4
+      - name: gopro
+        path: /mnt/other-videos
+        originalPath: /media/external/videos
   thumbnailPath: "/app/thumbnails"
   exportBasePath: "/app/exports"
   rustLog: "info"

src/config.rs

@@ -23,22 +23,67 @@ pub struct DatabaseConfig {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MediaPathConfig {
+    pub name: Option<String>,
     pub path: String,
     pub original_path: Option<String>,
     pub original_extension: Option<String>,
 }
 
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct MediaSourceConfig {
+    pub name: String,
+    pub path: String,
+    #[serde(rename = "originalPath")]
+    pub original_path: Option<String>,
+    #[serde(rename = "originalExtension")]
+    pub original_extension: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct MediaSourcePathsConfig {
+    pub sources: Option<Vec<MediaSourceConfig>>,
+    #[serde(skip)]
+    pub legacy_string: Option<String>,
+}
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct MediaConfig {
+    #[serde(rename = "mediaSourcePaths")]
+    pub media_source_paths_config: MediaSourcePathsConfig,
     pub source_paths: Vec<MediaPathConfig>,
+    #[serde(rename = "exportBasePath")]
     pub export_base_path: String,
+    #[serde(rename = "thumbnailPath")]
     pub thumbnail_path: String,
 }
 
+impl MediaConfig {
+    // Convert MediaSourcePathsConfig to Vec<MediaPathConfig>
+    pub fn convert_source_paths(&mut self) {
+        if let Some(sources) = &self.media_source_paths_config.sources {
+            // Convert each MediaSourceConfig to MediaPathConfig
+            self.source_paths = sources.iter().map(|source| {
+                MediaPathConfig {
+                    name: Some(source.name.clone()),
+                    path: source.path.clone(),
+                    original_path: source.original_path.clone(),
+                    original_extension: source.original_extension.clone(),
+                }
+            }).collect();
+        } else if let Some(legacy_string) = &self.media_source_paths_config.legacy_string {
+            // If we have a legacy string, parse it
+            self.source_paths = parse_comma_separated_paths_from_string(legacy_string);
+        } else {
+            // If no sources are defined, use environment variables as fallback
+            self.source_paths = parse_comma_separated_paths("MEDIA_SOURCE_PATHS");
+        }
+    }
+}
+
 impl Config {
     pub fn load() -> Result<Self> {
         // Default configuration
-        let config = Config {
+        let mut config = Config {
             server: ServerConfig {
                 host: env::var("SERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
                 port: env::var("SERVER_PORT")
@@ -54,26 +99,179 @@ impl Config {
                     .unwrap_or(5),
             },
             media: MediaConfig {
-                source_paths: parse_comma_separated_paths("MEDIA_SOURCE_PATHS"),
+                media_source_paths_config: MediaSourcePathsConfig {
+                    sources: None,
+                    legacy_string: env::var("MEDIA_SOURCE_PATHS").ok(),
+                },
+                source_paths: Vec::new(), // Will be populated in convert_source_paths
                 export_base_path: env::var("EXPORT_BASE_PATH")
                     .unwrap_or_else(|_| "./exports".to_string()),
                 thumbnail_path: env::var("THUMBNAIL_PATH")
                     .unwrap_or_else(|_| "./thumbnails".to_string()),
             },
         };
 
+        // Convert media_source_paths_config to source_paths
+        config.media.convert_source_paths();
+
         Ok(config)
     }
 }
 
+fn parse_comma_separated_paths_from_string(paths_str: &str) -> Vec<MediaPathConfig> {
+    paths_str
+        .split(',')
+        .map(|s| s.trim().to_string())
+        .map(|path_config| {
+            // Check if the path contains a named section (e.g., "bmpcc:")
+            if let Some(colon_pos) = path_config.find(':') {
+                let name = path_config[..colon_pos].trim().to_string();
+                let config_str = path_config[colon_pos + 1..].trim().to_string();
+
+                // Split the configuration by semicolons
+                let parts: Vec<&str> = config_str.split(';').collect();
+
+                if parts.is_empty() {
+                    // Invalid configuration, return a default
+                    return MediaPathConfig {
+                        name: Some(name),
+                        path: "./media".to_string(),
+                        original_path: None,
+                        original_extension: None,
+                    };
+                }
+
+                let path = parts[0].to_string();
+
+                // Parse original_path if provided
+                let original_path = parts.get(1)
+                    .filter(|&p| !p.is_empty())
+                    .map(|p| p.to_string());
+
+                // Parse original_extension if provided
+                let original_extension = parts.get(2)
+                    .filter(|&e| !e.is_empty())
+                    .map(|e| e.to_string());
+
+                // If original_path is provided without extension, use the same extension as path
+                let original_extension = if original_path.is_some() && original_extension.is_none() {
+                    // Extract extension from path
+                    std::path::Path::new(&path)
+                        .extension()
+                        .and_then(|ext| ext.to_str())
+                        .map(|ext| ext.to_string())
+                } else {
+                    original_extension
+                };
+
+                MediaPathConfig {
+                    name: Some(name),
+                    path,
+                    original_path,
+                    original_extension,
+                }
+            }
+            // Backward compatibility: Check if the path contains configuration options without a name
+            else if path_config.contains(';') {
+                let parts: Vec<&str> = path_config.split(';').collect();
+                let path = parts[0].to_string();
+
+                // Parse original_path if provided
+                let original_path = parts.get(1)
+                    .filter(|&p| !p.is_empty())
+                    .map(|p| p.to_string());
+
+                // Parse original_extension if provided
+                let original_extension = parts.get(2)
+                    .filter(|&e| !e.is_empty())
+                    .map(|e| e.to_string());
+
+                // If original_path is provided without extension, use the same extension as path
+                let original_extension = if original_path.is_some() && original_extension.is_none() {
+                    // Extract extension from path
+                    std::path::Path::new(&path)
+                        .extension()
+                        .and_then(|ext| ext.to_str())
+                        .map(|ext| ext.to_string())
+                } else {
+                    original_extension
+                };
+
+                MediaPathConfig {
+                    name: None,
+                    path,
+                    original_path,
+                    original_extension,
+                }
+            } else {
+                // Simple path without additional configuration
+                MediaPathConfig {
+                    name: None,
+                    path: path_config,
+                    original_path: None,
+                    original_extension: None,
+                }
+            }
+        })
+        .collect()
+}
+
 fn parse_comma_separated_paths(env_var: &str) -> Vec<MediaPathConfig> {
     env::var(env_var)
         .unwrap_or_else(|_| "./media".to_string())
         .split(',')
         .map(|s| s.trim().to_string())
         .map(|path_config| {
-            // Check if the path contains configuration options
-            if path_config.contains(';') {
+            // Check if the path contains a named section (e.g., "bmpcc:")
+            if let Some(colon_pos) = path_config.find(':') {
+                let name = path_config[..colon_pos].trim().to_string();
+                let config_str = path_config[colon_pos + 1..].trim().to_string();
+
+                // Split the configuration by semicolons
+                let parts: Vec<&str> = config_str.split(';').collect();
+
+                if parts.is_empty() {
+                    // Invalid configuration, return a default
+                    return MediaPathConfig {
+                        name: Some(name),
+                        path: "./media".to_string(),
+                        original_path: None,
+                        original_extension: None,
+                    };
+                }
+
+                let path = parts[0].to_string();
+
+                // Parse original_path if provided
+                let original_path = parts.get(1)
+                    .filter(|&p| !p.is_empty())
+                    .map(|p| p.to_string());
+
+                // Parse original_extension if provided
+                let original_extension = parts.get(2)
+                    .filter(|&e| !e.is_empty())
+                    .map(|e| e.to_string());
+
+                // If original_path is provided without extension, use the same extension as path
+                let original_extension = if original_path.is_some() && original_extension.is_none() {
+                    // Extract extension from path
+                    std::path::Path::new(&path)
+                        .extension()
+                        .and_then(|ext| ext.to_str())
+                        .map(|ext| ext.to_string())
+                } else {
+                    original_extension
+                };
+
+                MediaPathConfig {
+                    name: Some(name),
+                    path,
+                    original_path,
+                    original_extension,
+                }
+            }
+            // Backward compatibility: Check if the path contains configuration options without a name
+            else if path_config.contains(';') {
                 let parts: Vec<&str> = path_config.split(';').collect();
                 let path = parts[0].to_string();
 
@@ -87,14 +285,27 @@ fn parse_comma_separated_paths(env_var: &str) -> Vec<MediaPathConfig> {
                     .filter(|&e| !e.is_empty())
                     .map(|e| e.to_string());
 
+                // If original_path is provided without extension, use the same extension as path
+                let original_extension = if original_path.is_some() && original_extension.is_none() {
+                    // Extract extension from path
+                    std::path::Path::new(&path)
+                        .extension()
+                        .and_then(|ext| ext.to_str())
+                        .map(|ext| ext.to_string())
+                } else {
+                    original_extension
+                };
+
                 MediaPathConfig {
+                    name: None,
                     path,
                     original_path,
                     original_extension,
                 }
             } else {
                 // Simple path without additional configuration
                 MediaPathConfig {
+                    name: None,
                     path: path_config,
                     original_path: None,
                     original_extension: None,

src/services/scanner.rs

@@ -202,18 +202,29 @@ impl ScannerService {
                     None
                 };
 
-                // Check for original file if original_path and original_extension are specified
-                let original_file_path = if let (Some(original_path), Some(original_extension)) =
-                    (&path_config.original_path, &path_config.original_extension) {
-
+                // Check for original file if original_path is specified
+                let original_file_path = if let Some(original_path) = &path_config.original_path {
                     // Get the file name without extension
                     let file_stem = std::path::Path::new(&file_name)
                         .file_stem()
                         .map(|s| s.to_string_lossy().to_string());
 
                     if let Some(stem) = file_stem {
+                        // Determine the extension to use
+                        let extension = if let Some(original_extension) = &path_config.original_extension {
+                            // Use the specified original extension
+                            original_extension.clone()
+                        } else {
+                            // Use the extension from the scan path
+                            std::path::Path::new(&file_path)
+                                .extension()
+                                .and_then(|ext| ext.to_str())
+                                .unwrap_or("mp4")
+                                .to_string()
+                        };
+
                         // Construct the path to the original file
-                        let original_file = format!("{}/{}.{}", original_path, stem, original_extension);
+                        let original_file = format!("{}/{}.{}", original_path, stem, extension);
                         let original_path_buf = std::path::Path::new(&original_file);
 
                         // Check if the original file exists