adaptions format for paradise hill

src/api.rs

@@ -819,19 +819,10 @@ async fn status(req: HttpRequest) -> Result<impl web::Responder, web::Error> {
         name: "Paradisehill".to_string(),
         description: "Porn Movies on Paradise Hill".to_string(),
         premium: false,
-        favicon: "https://en.paradisehill.cc/img/big-logo.svg".to_string(),
+        favicon: "https://www.google.com/s2/favicons?sz=64&domain=en.paradisehill.cc".to_string(),
         status: "active".to_string(),
         categories: vec![],
-        options: vec![ChannelOption {
-            id: "sort".to_string(),
-            title: "Sort".to_string(),
-            description: "Sort the Videos".to_string(), //"Sort the videos by Date or Name.".to_string(),
-            systemImage: "list.number".to_string(),
-            colorName: "blue".to_string(),
-            options: vec![
-            ],
-            multiSelect: false,
-        }],
+        options: vec![],
         nsfw: true,
         cacheDuration: None,
     });

src/providers/paradisehill.rs

@@ -4,7 +4,7 @@ use htmlentity::entity::{decode, ICodedDataTrait};
 use futures::future::join_all;
 use crate::providers::Provider;
 use crate::util::cache::VideoCache;
-use crate::videos::ServerOptions;
+use crate::videos::{self, ServerOptions};
 use crate::videos::{VideoItem};
 use crate::DbPool;
 use crate::util::requester::Requester;
@@ -145,15 +145,22 @@ impl ParadisehillProvider {
             .split("\"").collect::<Vec<&str>>()[0].replace("\\", "").to_string();
         let id = video_url.split("/").collect::<Vec<&str>>().last().unwrap().split("_").collect::<Vec<&str>>()[0]
             .to_string();
+
+        let format = videos::VideoFormat::new(video_url.clone(), "1080".to_string(), "mp4".to_string())
+        .protocol("https".to_string())
+        .format_id("mp4-1080")
+        ;
+
         let video_item = VideoItem::new(
             id,
             title,
-            video_url.clone(),
+            url_str.clone(),
             "paradisehill".to_string(),
             thumb,
             0,
         )
         .aspect_ratio(0.697674419 as f32)
+        .formats(vec![format])
         ;
 
         return Ok(video_item);

src/videos.rs

@@ -2,8 +2,6 @@ use std::collections::HashMap;
 
 use crate::util::requester::Requester;
 
-
-
 #[derive(serde::Serialize, serde::Deserialize, Debug)]
 pub struct VideosRequest {
     //"versionInstallDate":"2025-06-03T18:20:20Z","languageCode":"en","appInstallDate":"2025-06-03T18:20:20Z","server":"spacemoehre","sexu
@@ -41,7 +39,7 @@ pub struct ServerOptions{
     pub sites: Option<String>,    //
     pub filter: Option<String>,
     pub language: Option<String>, // "en"
-    pub requester: Option<Requester>
+    pub requester: Option<Requester>,
 }
 
 #[derive(serde::Serialize, Debug)]
@@ -50,7 +48,6 @@ pub struct PageInfo {
     pub resultsPerPage: u32, // 10
 }
 
-
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
 pub struct VideoEmbed {
     pub html: String,
@@ -58,10 +55,7 @@ pub struct VideoEmbed{
 }
 impl VideoEmbed {
     pub fn new(html: String, source: String) -> Self {
-        VideoEmbed {
-            html,
-            source,
-        }
+        VideoEmbed { html, source }
     }
 }
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
@@ -93,7 +87,7 @@ pub struct VideoItem {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub preview: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub aspectRation: Option<f32>
+    pub aspectRation: Option<f32>,
 }
 #[allow(dead_code)]
 impl VideoItem {
@@ -122,7 +116,7 @@ impl VideoItem {
             formats: None, // Placeholder for formats
             embed: None,   // Placeholder for embed information
             preview: None,
-            aspectRation: None
+            aspectRation: None,
         }
     }
     pub fn tags(mut self, tags: Vec<String>) -> Self {
@@ -228,7 +222,6 @@ pub struct VideoFormat {
     resolution: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     http_headers: Option<HashMap<String, String>>,
-    
 }
 impl VideoFormat {
     pub fn new(url: String, quality: String, format: String) -> Self {
@@ -269,6 +262,94 @@ impl VideoFormat {
             headers.insert(key, value);
         }
     }
+    pub fn format_id(mut self, format_id: String) -> Self {
+        self.format_id = Some(format_id);
+        self
+    }
+    pub fn format_note(mut self, format_note: String) -> Self {
+        self.format_note = Some(format_note);
+        self
+    }
+    pub fn filesize(mut self, filesize: u32) -> Self {
+        self.filesize = Some(filesize);
+        self
+    }
+    pub fn asr(mut self, asr: u32) -> Self {
+        self.asr = Some(asr);
+        self
+    }
+    pub fn fps(mut self, fps: u32) -> Self {
+        self.fps = Some(fps);
+        self
+    }
+    pub fn width(mut self, width: u32) -> Self {
+        self.width = Some(width);
+        self
+    }
+    pub fn height(mut self, height: u32) -> Self {
+        self.height = Some(height);
+        self
+    }
+    pub fn tbr(mut self, tbr: u32) -> Self {
+        self.tbr = Some(tbr);
+        self
+    }
+    pub fn language(mut self, language: String) -> Self {
+        self.language = Some(language);
+        self
+    }
+    pub fn language_preference(mut self, language_preference: u32) -> Self {
+        self.language_preference = Some(language_preference);
+        self
+    }
+    pub fn ext(mut self, ext: String) -> Self {
+        self.ext = Some(ext);
+        self
+    }
+    pub fn vcodec(mut self, vcodec: String) -> Self {
+        self.vcodec = Some(vcodec);
+        self
+    }
+    pub fn acodec(mut self, acodec: String) -> Self {
+        self.acodec = Some(acodec);
+        self
+    }
+    pub fn dynamic_range(mut self, dynamic_range: String) -> Self {
+        self.dynamic_range = Some(dynamic_range);
+        self
+    }
+    pub fn abr(mut self, abr: u32) -> Self {
+        self.abr = Some(abr);
+        self
+    }
+    pub fn vbr(mut self, vbr: u32) -> Self {
+        self.vbr = Some(vbr);
+        self
+    }
+    pub fn container(mut self, container: String) -> Self {
+        self.container = Some(container);
+        self
+    }
+    pub fn protocol(mut self, protocol: String) -> Self {
+        self.protocol = Some(protocol);
+        self
+    }
+    pub fn audio_ext(mut self, audio_ext: String) -> Self {
+        self.audio_ext = Some(audio_ext);
+        self
+    }
+    pub fn video_ext(mut self, video_ext: String) -> Self {
+        self.video_ext = Some(video_ext);
+        self
+    }
+    pub fn resolution(mut self, resolution: String) -> Self {
+        self.resolution = Some(resolution);
+        self
+    }
+    pub fn http_headers(mut self, http_headers: HashMap<String, String>) -> Self {
+        self.http_headers = Some(http_headers);
+        self
+    }
 }
 #[derive(serde::Serialize, Debug)]
 pub struct Videos {