feat(server): fix the sync scheduler for sources

src/lib.rs

@@ -36,6 +36,7 @@ pub struct AppState {
     pub db: Database,
     pub config: Config,
     pub webdav_scheduler: Option<std::sync::Arc<webdav_scheduler::WebDAVScheduler>>,
+    pub source_scheduler: Option<std::sync::Arc<source_scheduler::SourceScheduler>>,
 }
 
 /// Health check endpoint for monitoring

src/main.rs

@@ -135,6 +135,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         db: web_db, 
         config: config.clone(),
         webdav_scheduler: None, // Will be set after creating scheduler
+        source_scheduler: None, // Will be set after creating scheduler
     };
     let web_state = Arc::new(web_state);
     
@@ -143,6 +144,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         db: background_db,
         config: config.clone(),
         webdav_scheduler: None,
+        source_scheduler: None,
     };
     let background_state = Arc::new(background_state);
     
@@ -220,6 +222,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         db: web_state.db.clone(),
         config: web_state.config.clone(),
         webdav_scheduler: Some(webdav_scheduler.clone()),
+        source_scheduler: Some(source_scheduler.clone()),
     };
     let web_state = Arc::new(updated_web_state);
     

src/routes/sources.rs

@@ -7,6 +7,7 @@ use axum::{
 };
 use std::sync::Arc;
 use uuid::Uuid;
+use tracing::error;
 
 use crate::{
     auth::AuthUser,
@@ -262,26 +263,52 @@ async fn trigger_sync(
         .await
         .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
 
-    // Trigger the appropriate sync based on source type
+    // Trigger sync using the universal source scheduler
-    match source.source_type {
+    if let Some(scheduler) = &state.source_scheduler {
-        crate::models::SourceType::WebDAV => {
+        if let Err(e) = scheduler.trigger_sync(source_id).await {
-            // Send a message to trigger WebDAV sync
+            error!("Failed to trigger sync for source {}: {}", source_id, e);
-            if let Some(scheduler) = &state.webdav_scheduler {
-                scheduler.trigger_sync(source_id).await;
-            }
-        }
-        _ => {
-            // Other source types not implemented yet
             state
                 .db
                 .update_source_status(
                     source_id,
                     crate::models::SourceStatus::Error,
-                    Some("Source type not implemented".to_string()),
+                    Some(format!("Failed to trigger sync: {}", e)),
                 )
                 .await
                 .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
-            return Err(StatusCode::NOT_IMPLEMENTED);
+            return Err(StatusCode::INTERNAL_SERVER_ERROR);
+        }
+    } else {
+        // Fallback to WebDAV scheduler for backward compatibility
+        match source.source_type {
+            crate::models::SourceType::WebDAV => {
+                if let Some(webdav_scheduler) = &state.webdav_scheduler {
+                    webdav_scheduler.trigger_sync(source_id).await;
+                } else {
+                    state
+                        .db
+                        .update_source_status(
+                            source_id,
+                            crate::models::SourceStatus::Error,
+                            Some("No scheduler available".to_string()),
+                        )
+                        .await
+                        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+                    return Err(StatusCode::INTERNAL_SERVER_ERROR);
+                }
+            }
+            _ => {
+                state
+                    .db
+                    .update_source_status(
+                        source_id,
+                        crate::models::SourceStatus::Error,
+                        Some("Source type not supported".to_string()),
+                    )
+                    .await
+                    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+                return Err(StatusCode::NOT_IMPLEMENTED);
+            }
         }
     }