Another attempt at rescan, can't test locally without more substantial effort. Testing directly on deployment since this is in alpha/noone but me :D

Author: devclef

frontend/src/pages/SystemInfoPage.tsx

@@ -83,7 +83,7 @@ const SystemInfoPage: React.FC = () => {
 
       toast({
         title: 'Library Rescanned',
-        description: `Successfully rescanned library. Found ${data.new_videos_count} new videos.`,
+        description: `Successfully rescanned library. Found ${data.new_videos_count} new videos and updated ${data.updated_videos_count} existing videos.`,
         status: 'success',
         duration: 5000,
         isClosable: true,

src/routes/scan.rs

@@ -15,6 +15,8 @@ pub fn router(app_state: AppState) -> Router {
 struct ScanResponse {
     new_videos_count: usize,
     new_videos: Vec<crate::models::Video>,
+    updated_videos_count: usize,
+    updated_videos: Vec<crate::models::Video>,
 }
 
 async fn scan_directories(State(state): State<AppState>) -> Result<Json<ScanResponse>> {
@@ -31,7 +33,7 @@ async fn scan_directories(State(state): State<AppState>) -> Result<Json<ScanResp
     let source_paths = state.config.media.source_paths.clone();
 
     // Scan directories
-    let new_videos = ScannerService::scan_directories(
+    let (new_videos, updated_videos) = ScannerService::scan_directories(
         &source_paths,
         &video_service,
         &thumbnail_service,
@@ -40,6 +42,8 @@ async fn scan_directories(State(state): State<AppState>) -> Result<Json<ScanResp
     let response = ScanResponse {
         new_videos_count: new_videos.len(),
         new_videos,
+        updated_videos_count: updated_videos.len(),
+        updated_videos,
     };
 
     Ok(Json(response))

src/services/scanner.rs

@@ -137,8 +137,9 @@ impl ScannerService {
         path_configs: &[crate::config::MediaPathConfig],
         video_service: &VideoService,
         thumbnail_service: &ThumbnailService,
-    ) -> Result<Vec<Video>, AppError> {
+    ) -> Result<(Vec<Video>, Vec<Video>), AppError> {
         let mut new_videos = Vec::new();
+        let mut updated_videos = Vec::new();
 
         for path_config in path_configs {
             info!("Scanning directory: {}", path_config.path);
@@ -161,13 +162,6 @@ impl ScannerService {
                 let file_path = entry.path().to_string_lossy().to_string();
                 let file_name = entry.file_name().to_string_lossy().to_string();
 
-                // Check if video already exists in database
-                if video_service.find_by_path(&file_path).await.is_ok() {
-                    continue;
-                }
-
-                info!("Found new video: {}", file_path);
-
                 // Get file metadata
                 let metadata = match fs::metadata(&file_path).await {
                     Ok(m) => m,
@@ -195,9 +189,6 @@ impl ScannerService {
                     }
                 };
 
-                // Create video record
-                let file_name_clone = file_name.clone();
-
                 // Extract duration for video files
                 let duration = if let Some(ext) = std::path::Path::new(&file_path).extension() {
                     let ext = ext.to_string_lossy().to_lowercase();
@@ -240,6 +231,37 @@ impl ScannerService {
                     None
                 };
 
+                // Check if video already exists in database
+                match video_service.find_by_path(&file_path).await {
+                    Ok(existing_video) => {
+                        // Update existing video with new metadata
+                        info!("Updating existing video: {}", file_path);
+                        match video_service.update_technical_metadata(
+                            &existing_video.id,
+                            Some(metadata.len() as i64),
+                            duration,
+                            thumbnail_path,
+                            original_file_path
+                        ).await {
+                            Ok(updated_video) => {
+                                updated_videos.push(updated_video);
+                            },
+                            Err(e) => {
+                                error!("Error updating video metadata: {}", e);
+                            }
+                        }
+                        continue;
+                    },
+                    Err(_) => {
+                        // Video doesn't exist, continue with creation
+                    }
+                };
+
+                info!("Found new video: {}", file_path);
+
+                // Create video record
+                let file_name_clone = file_name.clone();
+
                 let create_dto = CreateVideoDto {
                     file_path,
                     file_name,
@@ -266,8 +288,8 @@ impl ScannerService {
             }
         }
 
-        info!("Scan complete. Found {} new videos", new_videos.len());
-        Ok(new_videos)
+        info!("Scan complete. Found {} new videos and updated {} existing videos", new_videos.len(), updated_videos.len());
+        Ok((new_videos, updated_videos))
     }
 
     fn get_video_files(dir: &Path) -> Result<Vec<walkdir::DirEntry>> {

src/services/video.rs

@@ -278,6 +278,56 @@ impl VideoService {
         self.find_by_id(id).await
     }
 
+    pub async fn update_technical_metadata(&self, id: &str, file_size: Option<i64>, duration: Option<i64>, thumbnail_path: Option<String>, original_file_path: Option<String>) -> Result<Video> {
+        let mut tx = self.db.begin().await.map_err(AppError::Database)?;
+
+        // Check if video exists
+        let video = self.find_by_id(id).await?;
+        let now = chrono::Utc::now().to_rfc3339();
+
+        // Update video fields
+        let mut query = "UPDATE videos SET updated_at = ?".to_string();
+        let mut params: Vec<String> = vec![now.clone()];
+
+        if let Some(size) = file_size {
+            query.push_str(", file_size = ?");
+            params.push(size.to_string());
+        }
+
+        if let Some(dur) = duration {
+            query.push_str(", duration = ?");
+            params.push(dur.to_string());
+        }
+
+        if let Some(thumb) = &thumbnail_path {
+            query.push_str(", thumbnail_path = ?");
+            params.push(thumb.clone());
+        }
+
+        if let Some(orig) = &original_file_path {
+            query.push_str(", original_file_path = ?");
+            params.push(orig.clone());
+        }
+
+        query.push_str(" WHERE id = ?");
+        params.push(id.to_string());
+
+        let mut query_builder = sqlx::query(&query);
+        for param in params {
+            query_builder = query_builder.bind(param);
+        }
+
+        query_builder
+            .execute(&mut *tx)
+            .await
+            .map_err(AppError::Database)?;
+
+        tx.commit().await.map_err(AppError::Database)?;
+
+        // Return the updated video (find_by_id already transforms the thumbnail path)
+        self.find_by_id(id).await
+    }
+
     pub async fn delete(&self, id: &str) -> Result<()> {
         let video = self.find_by_id(id).await?;