feat: add mark season as watched for videos

src/models/meta_details.rs

@@ -131,6 +131,33 @@ 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_by_season(*season));
+
+                    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 =>
             {

src/models/player.rs

@@ -675,6 +675,37 @@ 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 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_by_season(*season));
+
+                        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,

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)]

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 {

src/types/resource/meta_item.rs

@@ -265,6 +265,19 @@ impl MetaItem {
             Either::Right(self.videos.iter().rev())
         }
     }
+
+    /// Returns a vector of videos for a given season
+    pub fn videos_by_season(&self, season: u32) -> Vec<&Video> {
+        self.videos
+            .iter()
+            .filter(|video| {
+                video
+                    .series_info
+                    .as_ref()
+                    .is_some_and(|series_info| series_info.season == season)
+            })
+            .collect_vec()
+    }
 }
 
 #[derive(Default, Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]