add playlist response mapping

src/client/mod.rs

@@ -1,4 +1,5 @@
-mod player;
+pub mod player;
+pub mod playlist;
 mod response;
 
 use std::sync::Arc;
@@ -122,7 +123,7 @@ const TVHTML5_CLIENT_VERSION: &str = "2.0";
 const DESKTOP_MUSIC_API_KEY: &str = "AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30";
 const DESKTOP_MUSIC_CLIENT_VERSION: &str = "1.20220727.01.00";
 
-const MOBILE_CLIENT_VERSION: &str = "17.10.35";
+const MOBILE_CLIENT_VERSION: &str = "17.29.35";
 const ANDROID_API_KEY: &str = "AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w";
 const IOS_API_KEY: &str = "AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc";
 const IOS_DEVICE_MODEL: &str = "iPhone14,5";
@@ -174,7 +175,7 @@ impl RustyTube {
         }
     }
 
-    pub fn get_ytclient(&self, client_type: ClientType) -> Arc<dyn YTClient> {
+    fn get_ytclient(&self, client_type: ClientType) -> Arc<dyn YTClient> {
         match client_type {
             ClientType::Desktop => self.desktop_client.clone(),
             ClientType::DesktopMusic => self.desktop_music_client.clone(),
@@ -205,8 +206,7 @@ pub struct DesktopClient {
     locale: Arc<Locale>,
     http: Client,
     cache: Cache,
-    consent_cookie_yes: String,
-    consent_cookie_no: String,
+    consent_cookie: String,
 }
 
 #[async_trait]
@@ -246,7 +246,7 @@ impl YTClient for DesktopClient {
             )
             .header(header::ORIGIN, "https://www.youtube.com")
             .header(header::REFERER, "https://www.youtube.com")
-            .header(header::COOKIE, self.consent_cookie_no.to_owned())
+            .header(header::COOKIE, self.consent_cookie.to_owned())
             .header("X-YouTube-Client-Name", "1")
             .header("X-YouTube-Client-Version", self.get_client_version().await)
     }
@@ -275,18 +275,12 @@ impl DesktopClient {
             locale,
             http,
             cache,
-            consent_cookie_yes: format!(
+            consent_cookie: format!(
                 "{}={}{}",
                 CONSENT_COOKIE,
                 CONSENT_COOKIE_YES,
                 rng.gen_range(100..1000)
             ),
-            consent_cookie_no: format!(
-                "{}={}{}",
-                CONSENT_COOKIE,
-                CONSENT_COOKIE_NO,
-                rng.gen_range(100..1000)
-            ),
         }
     }
 
@@ -312,7 +306,7 @@ impl DesktopClient {
 
     async fn get_client_version(&self) -> String {
         let http = self.http.clone();
-        let consent_cookie = self.consent_cookie_yes.clone();
+        let consent_cookie = self.consent_cookie.clone();
 
         let client_data = self
             .cache
@@ -549,8 +543,7 @@ pub struct DesktopMusicClient {
     locale: Arc<Locale>,
     http: Client,
     cache: Cache,
-    consent_cookie_yes: String,
-    consent_cookie_no: String,
+    consent_cookie: String,
 }
 
 #[async_trait]
@@ -593,7 +586,7 @@ impl YTClient for DesktopMusicClient {
             )
             .header(header::ORIGIN, "https://music.youtube.com")
             .header(header::REFERER, "https://music.youtube.com")
-            .header(header::COOKIE, self.consent_cookie_no.to_owned())
+            .header(header::COOKIE, self.consent_cookie.to_owned())
             .header("X-YouTube-Client-Name", "67")
             .header("X-YouTube-Client-Version", self.get_client_version().await)
     }
@@ -622,18 +615,12 @@ impl DesktopMusicClient {
             locale,
             http,
             cache,
-            consent_cookie_yes: format!(
+            consent_cookie: format!(
                 "{}={}{}",
                 CONSENT_COOKIE,
                 CONSENT_COOKIE_YES,
                 rng.gen_range(100..1000)
             ),
-            consent_cookie_no: format!(
-                "{}={}{}",
-                CONSENT_COOKIE,
-                CONSENT_COOKIE_NO,
-                rng.gen_range(100..1000)
-            ),
         }
     }
 
@@ -659,7 +646,7 @@ impl DesktopMusicClient {
 
     async fn get_client_version(&self) -> String {
         let http = self.http.clone();
-        let consent_cookie = self.consent_cookie_yes.clone();
+        let consent_cookie = self.consent_cookie.clone();
 
         let client_data = self
             .cache
@@ -696,7 +683,7 @@ mod tests {
         let client = rt.desktop_client;
         let version = DesktopClient::extract_client_version_from_swjs(
             client.http.clone(),
-            &client.consent_cookie_yes,
+            &client.consent_cookie,
         )
         .await
         .unwrap();
@@ -719,7 +706,7 @@ mod tests {
         let client = rt.desktop_music_client;
         let version = DesktopMusicClient::extract_client_version_from_swjs(
             client.http.clone(),
-            &client.consent_cookie_yes,
+            &client.consent_cookie,
         )
         .await
         .unwrap();

src/client/player.rs

@@ -15,7 +15,7 @@ use serde::Serialize;
 use url::Url;
 
 use super::{
-    response::{self, Player},
+    response,
     ClientType, ContextYT, RustyTube, YTClient,
 };
 use crate::{
@@ -64,11 +64,7 @@ struct QContentPlaybackContext {
 }
 
 impl RustyTube {
-    pub async fn fetch_player(
-        &self,
-        video_id: &str,
-        client_type: ClientType,
-    ) -> Result<PlayerData> {
+    pub async fn get_player(&self, video_id: &str, client_type: ClientType) -> Result<PlayerData> {
         let client = self.get_ytclient(client_type);
         let (context, deobf) = tokio::join!(
             client.get_context(false),
@@ -285,7 +281,7 @@ fn cmp_video_streams(a: &VideoStream, b: &VideoStream) -> Ordering {
     }
 }
 
-fn map_player_data(response: Player, deobf: &Deobfuscator) -> Result<PlayerData> {
+fn map_player_data(response: response::Player, deobf: &Deobfuscator) -> Result<PlayerData> {
     // Check playability status
     match response.playability_status {
         response::player::PlayabilityStatus::Ok { live_streamability } => {
@@ -417,7 +413,7 @@ fn map_player_data(response: Player, deobf: &Deobfuscator) -> Result<PlayerData>
 
 #[cfg(test)]
 mod tests {
-    use std::{fs, io::Cursor, path::Path};
+    use std::path::Path;
 
     use crate::{cache::DeobfData, client::CLIENT_TYPES};
 
@@ -460,8 +456,8 @@ mod tests {
             let mut json_path = tf_dir.to_path_buf();
             json_path.push(format!("{:?}_video.json", client_type).to_lowercase());
 
-            let mut file = fs::File::create(json_path).unwrap();
-            let mut content = Cursor::new(resp.bytes().await.unwrap());
+            let mut file = std::fs::File::create(json_path).unwrap();
+            let mut content = std::io::Cursor::new(resp.bytes().await.unwrap());
             std::io::copy(&mut content, &mut file).unwrap();
         }
     }
@@ -485,9 +481,9 @@ mod tests {
     #[case::android(ClientType::Android)]
     #[case::ios(ClientType::Ios)]
     #[test_log::test(tokio::test)]
-    async fn t_fetch_stream(#[case] client_type: ClientType) {
+    async fn t_get_player(#[case] client_type: ClientType) {
         let rt = RustyTube::new();
-        let player_data = rt.fetch_player("n4tK7LYFxI0", client_type).await.unwrap();
+        let player_data = rt.get_player("n4tK7LYFxI0", client_type).await.unwrap();
 
         // dbg!(player_data.clone());
 

src/client/playlist.rs

@@ -0,0 +1,116 @@
+// REQUEST
+
+use anyhow::{anyhow, bail, Result};
+use reqwest::Method;
+use serde::Serialize;
+
+use super::{response, ClientType, ContextYT, RustyTube};
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct QPlaylist {
+    context: ContextYT,
+    browse_id: String,
+}
+
+impl RustyTube {
+    pub async fn get_playlist(
+        &self,
+        playlist_id: &str,
+        client_type: ClientType,
+    ) -> Result<response::Playlist> {
+        // let client = self.desktop_client.clone();
+        let client = self.get_ytclient(client_type);
+        let context = client.get_context(true).await;
+
+        let request_body = QPlaylist {
+            context,
+            browse_id: "VL".to_owned() + playlist_id,
+        };
+
+        let resp = client
+            .request_builder(Method::POST, "browse")
+            .await
+            .json(&request_body)
+            .send()
+            .await?
+            .error_for_status()?;
+
+        let playlist_response = resp.json::<response::Playlist>().await?;
+
+        Ok(playlist_response)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use crate::client::ClientType;
+
+    use super::*;
+
+    #[allow(dead_code)]
+    // #[test_log::test(tokio::test)]
+    async fn download_testfiles() {
+        let tf_dir = Path::new("testfiles/playlist");
+        let playlist_id = "RDCLAK5uy_mHW5bcduhjB-PkTePAe6EoRMj1xNT8gzY";
+
+        let rt = RustyTube::new();
+
+        for client_type in [ClientType::Desktop, ClientType::DesktopMusic] {
+            let client = rt.get_ytclient(client_type);
+            let context = client.get_context(false).await;
+
+            let request_body = QPlaylist {
+                context,
+                browse_id: "VL".to_owned() + playlist_id,
+            };
+
+            let resp = client
+                .request_builder(Method::POST, "browse")
+                .await
+                .json(&request_body)
+                .send()
+                .await
+                .unwrap()
+                .error_for_status()
+                .unwrap();
+
+            let mut json_path = tf_dir.to_path_buf();
+            json_path.push(format!("{:?}_playlist.json", client_type).to_lowercase());
+
+            let mut file = std::fs::File::create(json_path).unwrap();
+            let mut content = std::io::Cursor::new(resp.bytes().await.unwrap());
+            std::io::copy(&mut content, &mut file).unwrap();
+        }
+    }
+
+    #[test_log::test(tokio::test)]
+    async fn t_get_playlist() {
+        let rt = RustyTube::new();
+        let playlist = rt
+            .get_playlist(
+                "RDCLAK5uy_mHW5bcduhjB-PkTePAe6EoRMj1xNT8gzY",
+                ClientType::Desktop,
+            )
+            .await
+            .unwrap();
+
+        dbg!(playlist);
+    }
+
+    #[test_log::test(tokio::test)]
+    async fn t_get_playlist_music() {
+        let rt = RustyTube::new();
+        let playlist = rt
+            .get_playlist(
+                "RDCLAK5uy_mHW5bcduhjB-PkTePAe6EoRMj1xNT8gzY",
+                ClientType::DesktopMusic,
+            )
+            .await
+            .unwrap();
+
+        dbg!(playlist);
+    }
+}

src/client/response/mod.rs

@@ -1,3 +1,74 @@
 pub mod player;
+pub mod playlist;
 
 pub use player::Player;
+pub use playlist::Playlist;
+
+use serde::Deserialize;
+use serde_with::{serde_as, VecSkipError};
+
+use crate::serializer::text::TextLink;
+
+#[derive(Default, Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Thumbnails {
+    pub thumbnails: Vec<Thumbnail>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Thumbnail {
+    pub url: String,
+    pub width: u32,
+    pub height: u32,
+}
+
+// YouTube Music
+
+#[serde_as]
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicItem {
+    thumbnail: MusicThumbnailRenderer,
+    playlist_item_data: PlaylistItemData,
+    #[serde(default)]
+    #[serde_as(as = "VecSkipError<_>")]
+    flex_columns: Vec<MusicColumn>,
+    #[serde(default)]
+    #[serde_as(as = "VecSkipError<_>")]
+    fixed_columns: Vec<MusicColumn>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicThumbnailRenderer {
+    music_thumbnail_renderer: MusicThumbnailRenderer2,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MusicThumbnailRenderer2 {
+    thumbnail: Thumbnails,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaylistItemData {
+    video_id: String,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct MusicColumn {
+    #[serde(
+        rename = "musicResponsiveListItemFlexColumnRenderer",
+        alias = "musicResponsiveListItemFixedColumnRenderer"
+    )]
+    renderer: MusicColumnRenderer,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Deserialize)]
+pub struct MusicColumnRenderer {
+    #[serde_as(as = "crate::serializer::text::TextLink")]
+    text: TextLink,
+}

src/client/response/player.rs

@@ -5,6 +5,8 @@ use serde::Deserialize;
 use serde_with::serde_as;
 use serde_with::{json::JsonString, DefaultOnError, VecSkipError};
 
+use super::Thumbnails;
+
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Player {
@@ -217,20 +219,6 @@ pub struct VideoDetails {
     pub is_live_content: bool,
 }
 
-#[derive(Default, Clone, Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Thumbnails {
-    pub thumbnails: Vec<Thumbnail>,
-}
-
-#[derive(Clone, Debug, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Thumbnail {
-    pub url: String,
-    pub width: u32,
-    pub height: u32,
-}
-
 #[derive(Clone, Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Microformat {

src/client/response/playlist.rs

@@ -0,0 +1,105 @@
+use serde::Deserialize;
+use serde_with::serde_as;
+use serde_with::{json::JsonString, DefaultOnError, VecSkipError};
+
+use crate::serializer::text::TextLink;
+
+use super::{Thumbnails, MusicItem};
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Playlist {
+    pub contents: Contents,
+    pub header: Header,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Contents {
+    #[serde(alias = "singleColumnBrowseResultsRenderer")]
+    pub two_column_browse_results_renderer: ContentsRenderer<Tab>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Tab {
+    pub tab_renderer: ContentRenderer<SectionList>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SectionList {
+    pub section_list_renderer: ContentsRenderer<ItemSection>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ItemSection {
+    pub item_section_renderer: Option<ContentsRenderer<PlaylistVideoList>>,
+    pub music_playlist_shelf_renderer: Option<ContentsRenderer<PlaylistMusicItem>>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaylistVideoList {
+    pub playlist_video_list_renderer: ContentsRenderer<PlaylistVideoItem>
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaylistVideoItem {
+    playlist_video_renderer: PlaylistVideo,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaylistMusicItem {
+    music_responsive_list_item_renderer: MusicItem,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlaylistVideo {
+    pub video_id: String,
+    pub thumbnail: Thumbnails,
+    #[serde_as(as = "crate::serializer::text::Text")]
+    pub title: String,
+    #[serde(rename = "shortBylineText")]
+    #[serde_as(as = "crate::serializer::text::TextLink")]
+    pub channel: TextLink,
+    #[serde_as(as = "JsonString")]
+    pub length_seconds: u32,
+    pub is_playable: bool,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Header {
+    #[serde(alias = "musicDetailHeaderRenderer")]
+    pub playlist_header_renderer: HeaderRenderer,
+}
+
+#[serde_as]
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HeaderRenderer {
+    pub playlist_id: Option<String>,
+    #[serde_as(as = "crate::serializer::text::Text")]
+    pub title: String,
+    #[serde_as(as = "Option<crate::serializer::text::Text>")]
+    pub description: Option<String>,
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ContentRenderer<T> {
+    pub content: T
+}
+
+#[derive(Clone, Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ContentsRenderer<T> {
+    #[serde(alias = "tabs")]
+    pub contents: Vec<T>
+}