adjusted requester to supply http::version itself

src/providers/noodlemagazine.rs

@@ -3,12 +3,15 @@ use crate::api::ClientVersion;
 use crate::providers::Provider;
 use crate::status::*;
 use crate::util::cache::VideoCache;
+use crate::util::requester::Requester;
 use crate::util::parse_abbreviated_number;
 use crate::util::time::parse_time_to_seconds;
-use crate::videos::{ServerOptions, VideoItem};
+use crate::videos::{ServerOptions, VideoFormat, VideoItem};
 use async_trait::async_trait;
 use error_chain::error_chain;
+use futures::future::join_all;
 use htmlentity::entity::{ICodedDataTrait, decode};
+use wreq::Version;
 use std::{vec};
 use titlecase::Titlecase;
 
@@ -76,9 +79,9 @@ impl NoodlemagazineProvider {
         };
 
         let mut requester = options.requester.clone().unwrap();
-        let text = requester.get(&video_url).await.unwrap();
+        let text = requester.get(&video_url, Some(Version::HTTP_2)).await.unwrap();
         let video_items: Vec<VideoItem> = self
-            .get_video_items_from_html(text.clone())
+            .get_video_items_from_html(text.clone(), requester.clone())
             .await;
         if !video_items.is_empty() {
             cache.remove(&video_url);
@@ -116,9 +119,9 @@ impl NoodlemagazineProvider {
 
         let mut requester = options.requester.clone().unwrap();
 
-        let text = requester.get(&video_url).await.unwrap();
+        let text = requester.get(&video_url, Some(Version::HTTP_2)).await.unwrap();
         let video_items: Vec<VideoItem> = self
-            .get_video_items_from_html(text.clone())
+            .get_video_items_from_html(text.clone(), requester.clone())
             .await;
         if !video_items.is_empty() {
             cache.remove(&video_url);
@@ -132,6 +135,7 @@ impl NoodlemagazineProvider {
     async fn get_video_items_from_html(
         &self,
         html: String,
+        requester: Requester,
     ) -> Vec<VideoItem> {
         if html.is_empty() || html.contains("404 Not Found") {
             return vec![];
@@ -143,24 +147,18 @@ impl NoodlemagazineProvider {
             .collect::<Vec<&str>>()[1..]
             .to_vec();
 
-        let mut video_items: Vec<VideoItem> = vec![];
-        for raw_video in raw_videos {
-            if let Ok(video_item) = self.get_video_item(raw_video.to_string()).await {
-                video_items.push(video_item);
-            }
-        }
-
-        // let futures = raw_videos
-        //     .into_iter()
-        //     .map(|el| self.get_video_item(el.to_string()));
-        // let results: Vec<Result<VideoItem>> = join_all(futures).await;
-        // let video_items: Vec<VideoItem> = results.into_iter().filter_map(Result::ok).collect();
+        let futures = raw_videos
+            .into_iter()
+            .map(|el| self.get_video_item(el.to_string(), requester.clone()));
+        let results: Vec<Result<VideoItem>> = join_all(futures).await;
+        let video_items: Vec<VideoItem> = results.into_iter().filter_map(Result::ok).collect();
         return video_items;
     }
 
     async fn get_video_item(
         &self,
         video_segment: String,
+        requester: Requester,
     ) -> Result<VideoItem> {
         let video_url: String = format!(
             "{}{}",
@@ -208,22 +206,52 @@ impl NoodlemagazineProvider {
             .collect::<Vec<&str>>()[0]
             .trim()).unwrap_or(0);
 
-        let proxy_url = format!(
-            "https://hottub.spacemoehre.de/proxy/noodlemagazine/watch/{}",
-            video_url.split("/").collect::<Vec<&str>>()[4]
-        );
+        let formats = match self.extract_media(&video_url, requester.clone()).await{
+            Some(f) => f,
+            None => return Err(Error::from("Failed to extract media formats")),
+        };
         let video_item = VideoItem::new(
             id,
             title,
-            proxy_url,
+            video_url,
             "noodlemagazine".to_string(),
             thumb,
             duration,
         )
         .views(views)
+        .formats(formats)
         ;
         return Ok(video_item);
     }
+
+    async fn extract_media(&self, video_url: &String, mut requester: Requester) -> Option<Vec<VideoFormat>> {
+        let text = requester.get(video_url, Some(Version::HTTP_2)).await.unwrap_or("".to_string());
+        if text.is_empty() {
+            return None;
+        }
+        let mut formats = vec![];
+        let json_str = text.split("window.playlist = ")
+                .collect::<Vec<&str>>()[1]
+                .split(";")
+                .collect::<Vec<&str>>()[0];
+        let json: serde_json::Value = serde_json::from_str(json_str).unwrap();
+        let sources = json["sources"].as_array().unwrap();
+        for source in sources {
+            let file = source["file"].as_str().unwrap().to_string();
+            let label = source["label"].as_str().unwrap_or("unknown").to_string();
+            let format = VideoFormat::new(
+                file,
+                "video/mp4".to_string(),
+                label.clone(),
+            )
+            .format_id(label.clone())
+            .format_note(label.clone())
+            .http_header("Referer".to_string(), video_url.clone())
+            ;
+            formats.push(format);
+        }
+        return Some(formats);
+    }
 }
 
 #[async_trait]