feat: add mark season as watched for videos

Stremio · Jan 22, 2025 · bfaff6b · bfaff6b
1 parent 43e3384
commit bfaff6b
Show file tree

Hide file tree

Showing 4 changed files with 112 additions and 0 deletions.
diff --git a/src/models/meta_details.rs b/src/models/meta_details.rs
@@ -1,5 +1,6 @@
 use std::{borrow::Cow, marker::PhantomData};
 
+use itertools::Itertools;
 use serde::{Deserialize, Serialize};
 
 use stremio_watched_bitfield::WatchedBitField;
@@ -131,6 +132,44 @@ impl<E: Env + 'static> UpdateWithCtx<E> for MetaDetails {
                 }
                 _ => Effects::none().unchanged(),
             },
+            Msg::Action(Action::MetaDetails(ActionMetaDetails::MarkSeasonAsWatched(
+                season,
+                is_watched,
+            ))) => match (&self.library_item, &self.watched) {
+                (Some(library_item), Some(watched)) => {
+                    // Find videos of given season from the first ready meta item loadable
+                    let videos = self
+                        .meta_items
+                        .iter()
+                        .find(|meta_item| matches!(&meta_item.content, Some(Loadable::Ready(_))))
+                        .and_then(|meta_item| meta_item.content.as_ref())
+                        .and_then(|meta_item| meta_item.ready())
+                        .map(|meta_item| {
+                            meta_item
+                                .videos
+                                .iter()
+                                .filter(|video| {
+                                    video
+                                        .series_info
+                                        .as_ref()
+                                        .is_some_and(|series_info| series_info.season == *season)
+                                })
+                                .collect_vec()
+                        });
+
+                    match videos {
+                        Some(videos) => {
+                            let mut library_item = library_item.to_owned();
+                            library_item.mark_videos_as_watched::<E>(watched, videos, *is_watched);
+
+                            Effects::msg(Msg::Internal(Internal::UpdateLibraryItem(library_item)))
+                                .unchanged()
+                        }
+                        None => Effects::none().unchanged(),
+                    }
+                }
+                _ => Effects::none().unchanged(),
+            },
             Msg::Internal(Internal::ResourceRequestResult(request, result))
                 if request.path.resource == META_RESOURCE_NAME =>
             {

diff --git a/src/models/player.rs b/src/models/player.rs
@@ -675,6 +675,47 @@ impl<E: Env + 'static> UpdateWithCtx<E> for Player {
                     _ => Effects::none().unchanged(),
                 }
             }
+            Msg::Action(Action::Player(ActionPlayer::MarkSeasonAsWatched(season, is_watched))) => {
+                match (&self.library_item, &self.watched) {
+                    (Some(library_item), Some(watched)) => {
+                        // Find videos of given season from the first ready meta item loadable
+                        let videos = self
+                            .meta_item
+                            .as_ref()
+                            .and_then(|meta_item| meta_item.content.as_ref())
+                            .and_then(|meta_item| meta_item.ready())
+                            .map(|meta_item| {
+                                meta_item
+                                    .videos
+                                    .iter()
+                                    .filter(|video| {
+                                        video.series_info.as_ref().is_some_and(|series_info| {
+                                            series_info.season == *season
+                                        })
+                                    })
+                                    .collect_vec()
+                            });
+
+                        match videos {
+                            Some(videos) => {
+                                let mut library_item = library_item.to_owned();
+                                library_item.mark_videos_as_watched::<E>(
+                                    watched,
+                                    videos,
+                                    *is_watched,
+                                );
+
+                                Effects::msg(Msg::Internal(Internal::UpdateLibraryItem(
+                                    library_item,
+                                )))
+                                .unchanged()
+                            }
+                            None => Effects::none().unchanged(),
+                        }
+                    }
+                    _ => Effects::none().unchanged(),
+                }
+            }
             Msg::Internal(Internal::LibraryChanged(_)) => {
                 let library_item_effects = library_item_update::<E>(
                     &mut self.library_item,

diff --git a/src/runtime/msg/action.rs b/src/runtime/msg/action.rs
@@ -117,6 +117,8 @@ pub enum ActionMetaDetails {
     ///
     /// [`LibraryItem`]: crate::types::library::LibraryItem
     MarkVideoAsWatched(Video, bool),
+    /// Mark all videos from given season as watched
+    MarkSeasonAsWatched(u32, bool),
 }
 
 #[derive(Clone, Deserialize, Debug)]
@@ -199,6 +201,8 @@ pub enum ActionPlayer {
     ///
     /// [`LibraryItem`]: crate::types::library::LibraryItem
     MarkVideoAsWatched(Video, bool),
+    /// Mark all videos from given season as watched
+    MarkSeasonAsWatched(u32, bool),
 }
 
 #[derive(Clone, Deserialize, Debug)]

diff --git a/src/types/library/library_item.rs b/src/types/library/library_item.rs
@@ -128,6 +128,34 @@ impl LibraryItem {
             };
         }
     }
+
+    pub fn mark_videos_as_watched<E: Env>(
+        &mut self,
+        watched: &WatchedBitField,
+        videos: Vec<&Video>,
+        is_watched: bool,
+    ) {
+        let mut watched = watched.to_owned();
+
+        for video in &videos {
+            watched.set_video(&video.id, is_watched);
+        }
+
+        self.state.watched = Some(watched.into());
+
+        if is_watched {
+            self.state.last_watched = match (
+                &self.state.last_watched,
+                videos.last().and_then(|last_video| last_video.released),
+            ) {
+                (Some(last_watched), Some(released)) if last_watched < &released => {
+                    Some(released.to_owned())
+                }
+                (None, released) => released.to_owned(),
+                (last_watched, _) => last_watched.to_owned(),
+            };
+        }
+    }
 }
 
 impl<E: Env + 'static> From<(&MetaItemPreview, PhantomData<E>)> for LibraryItem {