Merge pull request #684 from kestrel-x86/FIX-#662

Fix #662

Author: madeofpendletonwool

rust-api/src/database.rs

@@ -2229,6 +2229,42 @@ impl DatabasePool {
         }
     }
 
+    pub async fn update_episode_duration(&self, episode_id: i32, new_duration: i32, is_youtube: bool) -> AppResult<()> {
+        match self {
+            DatabasePool::Postgres(pool) => {
+                if is_youtube {
+                    sqlx::query(r#"UPDATE "YouTubeVideos" SET duration = $1 WHERE videoid = $2"#)
+                        .bind(new_duration)
+                        .bind(episode_id)
+                        .execute(pool)
+                        .await?;
+                } else {
+                    sqlx::query(r#"UPDATE "Episodes" SET episodeduration = $1 WHERE episodeid = $2"#)
+                        .bind(new_duration)
+                        .bind(episode_id)
+                        .execute(pool)
+                        .await?;
+                }
+            }
+            DatabasePool::MySQL(pool) => {
+                if is_youtube {
+                    sqlx::query(r#"UPDATE YouTubeVideos SET duration = ? WHERE videoid = ?"#)
+                        .bind(new_duration)
+                        .bind(episode_id)
+                        .execute(pool)
+                        .await?;
+                } else {
+                    sqlx::query(r#"UPDATE Episodes SET episodeduration = ? WHERE episodeid = ?"#)
+                        .bind(new_duration)
+                        .bind(episode_id)
+                        .execute(pool)
+                        .await?;
+                }
+            }
+        }
+        Ok(())
+    }
+
     // Mark episode as completed - matches Python mark_episode_completed function
     pub async fn mark_episode_completed(&self, episode_id: i32, user_id: i32, is_youtube: bool) -> AppResult<()> {
         match self {

rust-api/src/handlers/podcasts.rs

@@ -1361,6 +1361,37 @@ pub async fn fetch_podcasting_2_pod_data(
     Ok(Json(data))
 }
 
+#[derive(Deserialize)]
+pub struct UpdateEpisodeDurationRequest {
+    pub episode_id: i32,
+    pub new_duration: i32,
+    pub is_youtube: bool,
+}
+
+pub async fn update_episode_duration(
+    headers: HeaderMap,
+    State(state): State<AppState>,
+    Json(request): Json<UpdateEpisodeDurationRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let api_key = extract_api_key(&headers)?;
+
+    // Verify API key
+    let is_valid = state.db_pool.verify_api_key(&api_key).await?;
+    if !is_valid {
+        return Err(AppError::unauthorized(
+            "Your API key is either invalid or does not have correct permission",
+        ));
+    }
+
+    state
+        .db_pool
+        .update_episode_duration(request.episode_id, request.new_duration, request.is_youtube)
+        .await?;
+    Ok(Json(
+        serde_json::json!({"detail": format!("Episode duration updated to {}", request.new_duration)}),
+    ))
+}
+
 // Request for mark_episode_completed - matches Python MarkEpisodeCompletedData
 #[derive(Deserialize)]
 pub struct MarkEpisodeCompletedRequest {

rust-api/src/main.rs

@@ -225,6 +225,7 @@ fn create_data_routes() -> Router<AppState> {
         .route("/get_play_episode_details", post(handlers::podcasts::get_play_episode_details))
         .route("/fetch_podcasting_2_pod_data", get(handlers::podcasts::fetch_podcasting_2_pod_data))
         .route("/mark_episode_completed", post(handlers::podcasts::mark_episode_completed))
+        .route("/update_episode_duration", post(handlers::podcasts::update_episode_duration))
         // Bulk episode operations
         .route("/bulk_mark_episodes_completed", post(handlers::episodes::bulk_mark_episodes_completed))
         .route("/bulk_save_episodes", post(handlers::episodes::bulk_save_episodes))

web/src/components/audio.rs

@@ -11,8 +11,8 @@ use crate::requests::pod_req::{
     call_get_auto_skip_times, call_get_episode_id, call_get_play_episode_details,
     call_get_podcast_id_from_ep, call_get_queued_episodes, call_increment_listen_time,
     call_increment_played, call_mark_episode_completed, call_queue_episode,
-    call_record_listen_duration, call_remove_queued_episode, HistoryAddRequest,
-    MarkEpisodeCompletedRequest, QueuePodcastRequest, RecordListenDurationRequest,
+    call_record_listen_duration, call_remove_queued_episode, call_update_episode_duration, HistoryAddRequest,
+    MarkEpisodeCompletedRequest, QueuePodcastRequest, RecordListenDurationRequest, UpdateEpisodeDurationRequest
 };
 use gloo_timers::callback::Interval;
 use js_sys::Array;
@@ -1994,8 +1994,17 @@ pub fn on_play_click(
             let actual_duration_sec = get_actual_duration(&src_for_analysis).await;
 
             // Use the actual duration if available, otherwise fall back to provided duration
-            let final_duration_sec =
-                actual_duration_sec.unwrap_or(episode_duration_for_wasm as f64);
+            let final_duration_sec = actual_duration_sec.unwrap_or(episode_duration_for_wasm as f64);
+
+            // Set actual duration in db
+            if (final_duration_sec as i32) != episode_duration_for_wasm {
+                let req = UpdateEpisodeDurationRequest {
+                    episode_id,
+                    new_duration: final_duration_sec as i32,
+                    is_youtube: episode_is_youtube,
+                };
+                call_update_episode_duration(&server_name_for_player, &Some(api_key_for_player.clone()), &req).await;
+            }
 
             web_sys::console::log_1(&JsValue::from_str(&format!(
                 "Original duration: {}s, Actual duration: {}s",

web/src/components/episode.rs

@@ -1756,7 +1756,7 @@ pub fn epsiode() -> Html {
                         // Before creating the play toggle handler, add this:
                         let listen_duration_percentage = if let Some(listen_duration) = episode.episode.listenduration {
                             if episode.episode.episodeduration > 0 {
-                                (listen_duration as f64 / episode.episode.episodeduration as f64) * 100.0
+                                ((listen_duration as f64 / episode.episode.episodeduration as f64) * 100.0).min(100.0)
                             } else {
                                 0.0
                             }

web/src/requests/pod_req.rs

@@ -3369,6 +3369,48 @@ pub async fn call_check_youtube_channel(
     }
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct UpdateEpisodeDurationRequest {
+    pub episode_id: i32,
+    pub new_duration: i32,
+    pub is_youtube: bool,
+}
+
+#[derive(Deserialize, Debug)]
+struct UpdateEpisodeDurationResponse {
+    detail: String,
+}
+
+pub async fn call_update_episode_duration(
+    server_name: &String,
+    api_key: &Option<String>,
+    request_data: &UpdateEpisodeDurationRequest,
+) -> Result<String, Error> {
+    let url = format!("{}/api/data/update_episode_duration", server_name);
+    let api_key_ref = api_key.as_deref().ok_or_else(|| anyhow::Error::msg("API key is missing"))?;
+
+    let request_body = serde_json::to_string(request_data).map_err(|e| anyhow::Error::msg(format!("Serialization Error: {}", e)))?;
+
+    let response = Request::post(&url)
+        .header("Api-Key", api_key_ref)
+        .header("Content-Type", "application/json")
+        .body(request_body)?
+        .send()
+        .await?;
+
+    if response.ok() {
+        let response_body: UpdateEpisodeDurationResponse = response.json().await.map_err(|e| anyhow::Error::new(e))?;
+        Ok(response_body.detail)
+    } else {
+        let error_text = response.text().await.unwrap_or_else(|_| String::from("Failed to read error message"));
+        Err(anyhow::Error::msg(format!(
+            "Failed to update episode duration: {} - {}",
+            response.status_text(),
+            error_text
+        )))
+    }
+}
+
 #[derive(Debug, Clone, Deserialize, PartialEq)]
 pub struct HomePodcast {
     pub podcastid: i32,