yugen.to moved to yugenanime.ru

src/anime/anime.rs

@@ -1,8 +1,8 @@
 use crate::{
-    get_an_history, get_an_progress, get_user_anime_progress, update_anime_progress,
+    get_an_history, get_an_progress, get_anime_id, get_user_anime_progress, update_anime_progress,
     write_an_progress,
 };
-use crate::{get_episode_link, get_episodes, get_image, search_anime};
+use crate::{get_anime_link, get_animes, get_image};
 use crate::{open_cast, open_video};
 
 use crossterm::{
@@ -22,6 +22,8 @@ use tui::{
 use unicode_width::UnicodeWidthStr;
 use viuer::{print_from_file, terminal_size, Config};
 
+use super::scraper::get_anime_info;
+
 enum InputMode {
     Normal,
     Editing,
@@ -88,8 +90,8 @@ struct App {
     input_mode: InputMode,
     /// History of recorded messages
     messages: StatefulList<String>,
-    episodes: (Vec<String>, Vec<String>),
     title: String,
+    link: String,
     ep: u64,
     progress: i32,
     anime_id: i32,
@@ -106,8 +108,8 @@ impl<'a> App {
             image: String::new(),
             input_mode: InputMode::Normal,
             messages: StatefulList::with_items(Vec::new()),
-            episodes: (Vec::new(), Vec::new()),
             title: String::new(),
+            link: String::new(),
             ep: 0,
             progress: 0,
             anime_id: 0,
@@ -255,14 +257,9 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
                             app.progress = 0;
                             let selected = app.messages.state.selected();
                             app.title = app.messages.items[selected.unwrap()].clone();
-                            app.anime_id = app.animes.0[selected.unwrap()]
+                            app.link = app.animes.0[selected.unwrap()].clone();
-                                .clone()
+                            let anime_info = get_anime_info(&app.animes.0[selected.unwrap()]);
-                                .parse::<i32>()
+                            app.anime_id = get_anime_id(anime_info.0);
-                                .unwrap();
-                            app.episodes = get_episodes(
-                                &app.animes.0[selected.unwrap()].parse::<i32>().unwrap(),
-                                &app.provider,
-                            );
                             app.messages.items.clear();
                             if app.token == "local" || app.anime_id == 0 {
                                 app.progress = get_an_progress(&app.title) as i32;
@@ -272,41 +269,27 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
                                     get_user_anime_progress(app.anime_id, app.token.as_str());
                                 app.messages.state.select(Some(app.progress as usize));
                             }
-                            if app.episodes.0.len() == 1 {
+                            if anime_info.1 == 1 {
-                                let link = get_episode_link(&app.episodes.1[0], &app.provider);
+                                let link = get_anime_link(&app.link, 1);
                                 if !app.cast.0 {
-                                    open_video((
+                                    open_video((link, format!("{} Episode 1", &app.title)));
-                                        link.0,
-                                        format!("{} Episode 1", &app.title),
-                                        link.1,
-                                    ));
                                 } else {
                                     open_cast(
-                                        (link.1, format!("{} Episode 1", &app.title)),
+                                        (link, format!("{} Episode 1", &app.title)),
                                         &app.cast.1,
                                     )
                                 }
                                 let selected = app.messages.state.selected();
                                 let image_url = app.animes.2[selected.unwrap()].clone();
                                 if app.token == "local" || app.anime_id == 0 {
-                                    write_an_progress(
+                                    write_an_progress((&app.title, &app.link, &image_url), &1);
-                                        (&app.title, &app.anime_id.to_string(), &image_url),
-                                        &1,
-                                    );
                                 } else {
                                     update_anime_progress(app.anime_id, 1, app.token.as_str());
-                                    write_an_progress(
+                                    write_an_progress((&app.title, &app.link, &image_url), &1);
-                                        (&app.title, &app.anime_id.to_string(), &image_url),
-                                        &1,
-                                    );
                                 }
                             } else {
-                                for ep in 1..app.episodes.1.len() + 1 {
+                                for ep in 1..anime_info.1 + 1 {
-                                    app.messages.push(format!(
+                                    app.messages.push(format!("Episode {}", ep));
-                                        "Episode {}: {}",
-                                        ep,
-                                        app.episodes.0[ep - 1]
-                                    ));
                                 }
                                 ep_select = true;
                             }
@@ -318,43 +301,28 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
                                 .nth(selected.unwrap())
                                 .unwrap()
                                 .replace("Episode ", "")
-                                .split(":")
-                                .collect::<Vec<&str>>()[0]
                                 .parse::<u64>()
                                 .unwrap();
-                            let link = get_episode_link(
+                            let link = get_anime_link(&app.link, app.ep);
-                                &app.episodes.1[app.ep as usize - 1],
-                                &app.provider,
-                            );
                             if !app.cast.0 {
-                                open_video((
+                                open_video((link, format!("{} Episode {}", &app.title, app.ep)));
-                                    link.0,
-                                    format!("{} Episode {}", &app.title, app.ep),
-                                    link.1,
-                                ));
                             } else {
                                 open_cast(
-                                    (link.0, format!("{} Episode {}", &app.title, app.ep)),
+                                    (link, format!("{} Episode {}", &app.title, app.ep)),
                                     &app.cast.1,
                                 )
                             }
                             let image_url = &app.image;
                             if app.ep > app.progress as u64 {
                                 if app.token == "local" || app.anime_id == 0 {
-                                    write_an_progress(
+                                    write_an_progress((&app.title, &app.link, &image_url), &app.ep);
-                                        (&app.title, &app.anime_id.to_string(), &image_url),
-                                        &app.ep,
-                                    );
                                 } else {
                                     update_anime_progress(
                                         app.anime_id,
                                         app.ep as usize,
                                         app.token.as_str(),
                                     );
-                                    write_an_progress(
+                                    write_an_progress((&app.title, &app.link, &image_url), &app.ep);
-                                        (&app.title, &app.anime_id.to_string(), &image_url),
-                                        &app.ep,
-                                    );
                                 }
                                 app.progress = app.ep as i32;
                             }
@@ -365,7 +333,7 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
                 InputMode::Editing => match key.code {
                     KeyCode::Enter => {
                         //push app.input into app.messages with '
-                        app.animes = search_anime(app.input.drain(..).collect());
+                        app.animes = get_animes(app.input.drain(..).collect());
                         app.messages.items.clear();
                         for anime in &app.animes.1 {
                             app.messages.push(anime.to_string());

src/anime/player.rs

@@ -8,8 +8,7 @@ use rust_cast::{
 };
 use std::str::FromStr;
 
-pub fn open_video(link: (String, String, String)) {
+pub fn open_video(link: (String, String)) {
-    if link.2 == "null" {
     let title = link.1;
     let title = title.replace("-", " ");
     let arg: String = format!("--force-media-title={}", title);
@@ -18,18 +17,7 @@ pub fn open_video(link: (String, String, String)) {
         .arg(arg)
         .output()
         .expect("failed to open mpv");
-    } else {
+
-        let title = link.1;
-        let title = title.replace("-", " ");
-        let arg1: String = format!("--force-media-title={}", title);
-        let arg2: String = format!("--sub-files={}", link.2);
-        let _ = std::process::Command::new("mpv")
-            .arg(link.0)
-            .arg(arg1)
-            .arg(arg2)
-            .output()
-            .expect("failed to open mpv");
-    }
     // clear terminal
 }
 

src/anime/scraper.rs

@@ -1,21 +1,14 @@
 use isahc::config::Configurable;
 use isahc::{ReadResponseExt, Request, RequestExt};
+use regex::Regex;
 use std::fs::File;
 use std::io::prelude::*;
 
 //use serde_json::json;
 
-pub fn search_anime(query: String) -> (Vec<String>, Vec<String>, Vec<String>) {
+pub fn get_anime_html(url: &str) -> String {
     let req = Request::builder()
-        .uri(format!(
+        .uri(url)
-            "https://api.consumet.org/meta/anilist/{}",
-            query
-                .replace(" ", "%20")
-                .replace(":", "%3A")
-                .replace("!", "%21")
-                .replace("?", "%3F")
-                .replace("'", "%27")
-        ))
         .redirect_policy(isahc::config::RedirectPolicy::Follow)
         .header(
             "user-agent",
@@ -23,95 +16,74 @@ pub fn search_anime(query: String) -> (Vec<String>, Vec<String>, Vec<String>) {
         )
         .body(())
         .unwrap();
-    let json = req.send().unwrap().text().unwrap();
+    req.send().unwrap().text().unwrap()
-    let json: serde_json::Value = serde_json::from_str(&json).unwrap();
+}
-    let mut titles = Vec::new();
+
-    let mut ids = Vec::new();
+pub fn get_post(id: &str) -> String {
-    let mut images = Vec::new();
+    let resp = Request::builder()
-    for i in 0..json["results"].as_array().unwrap().len() {
+        .method("POST")
-        titles.push(
+        .uri("https://yugenanime.ro/api/embed/")
-            json["results"][i]["title"]["userPreferred"]
+        .header("x-requested-with", "XMLHttpRequest")
-                .as_str()
+        .body(id)
         .unwrap()
-                .to_string(),
+        .send()
+        .unwrap()
+        .text();
+    let resp: String = resp.as_ref().unwrap().to_string();
+    resp
+}
+
+pub fn get_animes(query: String) -> (Vec<String>, Vec<String>, Vec<String>) {
+    let query = query.replace(" ", "+");
+    let html = get_anime_html(&format!("https://yugenanime.ro/discover/?q={}", query));
+    let re = Regex::new(r#"href="(/anime[^"]*)""#).unwrap();
+    let mut animes_links = Vec::new();
+    for cap in re.captures_iter(&html) {
+        animes_links.push(cap[1].to_string());
+    }
+    let re = Regex::new(r#"/" title="([^"]*)""#).unwrap();
+    let mut animes_names = Vec::new();
+    for cap in re.captures_iter(&html) {
+        animes_names.push(cap[1].to_string());
+    }
+    let re = Regex::new(r#"data-src="([^"]*)"#).unwrap();
+    let mut animes_images = Vec::new();
+    for cap in re.captures_iter(&html) {
+        animes_images.push(cap[1].to_string());
+    }
+    (animes_links, animes_names, animes_images)
+}
+
+pub fn get_anime_info(url: &str) -> (i32, u16) {
+    let url = format!("https://yugenanime.ro{}watch", url);
+    let html = get_anime_html(&url);
+    //print html and exit
+    let re = Regex::new(r#""mal_id":(\d*)"#).unwrap();
+    let mal_id = re.captures(&html).unwrap()[1].parse().unwrap();
+    let re =
+        Regex::new(r#"Episodes</div><span class="description" style="font-size: \d*px;">(\d*)"#)
+            .unwrap();
+    let episodes = re.captures(&html).unwrap()[1].parse().unwrap();
+    (mal_id, episodes)
+}
+
+pub fn get_anime_link(url: &str, episode: u64) -> String {
+    let url = &format!(
+        "https://yugenanime.ro/watch{}{}/",
+        url.replace("/anime", ""),
+        episode
     );
-
+    let html = get_anime_html(url);
-        ids.push(json["results"][i]["id"].as_str().unwrap().to_string());
+    let re = Regex::new(r#"/e/([^/]*)"#).unwrap();
-        //convert ids to i32
+    let capture = re.captures(&html).unwrap();
-        images.push(json["results"][i]["image"].as_str().unwrap().to_string());
+    let id = &capture[1];
-    }
+    let id = format!("id={}%3D&ac=0", id);
-    (ids, titles, images)
+    let json = get_post(&id);
-}
+    let re = Regex::new(r#"hls": \["(.*)","#).unwrap();
-
+    let capture = re.captures(&json).unwrap();
-pub fn get_episodes(id: &i32, provider: &str) -> (Vec<String>, Vec<String>) {
+    let link = &capture[1];
-    let req = Request::builder()
+    //return the link
-        .uri(format!(
+    link.to_string()
-            "https://api.consumet.org/meta/anilist/info/{}?provider={}",
-            id, provider
-        ))
-        .redirect_policy(isahc::config::RedirectPolicy::Follow)
-        .header(
-            "user-agent",
-            "Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/100.0",
-        )
-        .body(())
-        .unwrap();
-    let json = req.send().unwrap().text().unwrap();
-    let json: serde_json::Value = serde_json::from_str(&json).unwrap();
-    let mut titles = Vec::new();
-    let mut ids = Vec::new();
-    for i in 0..json["episodes"].as_array().unwrap().len() {
-        titles.push(json["episodes"][i]["title"].as_str().unwrap().to_string());
-        ids.push(json["episodes"][i]["id"].as_str().unwrap().to_string());
-    }
-    (titles, ids)
-}
-
-pub fn get_episode_link(ep_id: &str, provider: &str) -> (String, String) {
-    let req = Request::builder()
-        .uri(format!(
-            "https://api.consumet.org/meta/anilist/watch/{}?provider={}",
-            ep_id, provider
-        ))
-        .redirect_policy(isahc::config::RedirectPolicy::Follow)
-        .header(
-            "user-agent",
-            "Mozilla/5.0 (X11; Linux x86_64; rv:99.0) Gecko/20100101 Firefox/100.0",
-        )
-        .body(())
-        .unwrap();
-    let json = req.send().unwrap().text().unwrap();
-    let json: serde_json::Value = serde_json::from_str(&json).unwrap();
-    let mut url = String::new();
-    std::fs::write("test.json", json.to_string()).unwrap();
-    let mut subtitle = String::new();
-    let _error_vec = Vec::new();
-    let sub_array = json["subtitles"].as_array().unwrap_or(&_error_vec);
-    for i in 0..sub_array.len() {
-        //set subtitle to lang = English
-        if json["subtitles"][i]["lang"].as_str().unwrap_or("null") == "English" {
-            subtitle = json["subtitles"][i]["url"]
-                .as_str()
-                .unwrap_or("null")
-                .to_string();
-            // add \ before the first : in the url
-            subtitle = subtitle.replace(":", "\\:");
-        }
-    }
-    let mut highest_quality = 0;
-    for i in 0..json["sources"].as_array().unwrap().len() {
-        let quality = json["sources"][i]["quality"]
-            .as_str()
-            .unwrap()
-            .replace("p", "")
-            .parse::<i32>()
-            .unwrap_or(0);
-        if quality > highest_quality {
-            highest_quality = quality;
-            url = json["sources"][i]["url"].as_str().unwrap().to_string();
-        }
-    }
-    (url.to_string(), subtitle)
 }
 
 pub fn get_image(url: &str, path: &str) {

src/anime/trackers.rs

@@ -40,6 +40,54 @@ pub fn get_token() -> String {
     token
 }
 
+pub fn get_anime_id(mal_id: i32) -> i32 {
+    const QUERY: &str = "
+query ($id: Int, $search: Int) {
+    Media (id: $id, idMal: $search, type: ANIME) {
+        id
+        title {
+            native
+            romaji
+            english
+        }
+    }
+}
+";
+    let json = json!({
+        "query": QUERY,
+        "variables": {
+            "search": mal_id
+        }
+    });
+    let resp = Request::builder()
+        .method("POST")
+        .uri("https://graphql.anilist.co/")
+        .header("Content-Type", "application/json")
+        .header("Accept", "application/json")
+        .body(json.to_string())
+        .unwrap()
+        .send()
+        .unwrap()
+        .text();
+    let regex = regex::Regex::new(r#"id":(.*?),"#).unwrap();
+    let resp: String = resp.as_ref().unwrap().to_string();
+    //if error let id = 0
+    let id = match regex.captures(&resp) {
+        Some(captures) => captures[1].parse::<i32>().unwrap(),
+        None => 0,
+    };
+
+    // let id = regex
+    //     .captures(&resp)
+    //     .unwrap()
+    //     .get(1)
+    //     .unwrap()
+    //     .as_str()
+    //     .parse::<i32>()
+    //     .unwrap();
+    id
+}
+
 //get the user id from the token
 fn get_user_id(token: &str) -> i32 {
     const QUERY: &str = "query {

src/main.rs

@@ -28,14 +28,14 @@ fn main() {
                 if let Some(arg) = std::env::args().nth(count + 1) {
                     //get the next argument and see if it is = to gogo of vrv
                     match arg.as_str() {
-                        "zoro" | "gogoanime" => {
+                        "vrv" | "gogo" => {
                             provider = arg;
                             count += 1;
                         }
-                        &_ => provider = "gogoanime".to_string(),
+                        &_ => provider = "gogo".to_string(),
                     }
                 } else {
-                    provider = "zoro".to_string();
+                    provider = "vrv".to_string();
                 }
             }
             "--reader" | "-R" => {
@@ -48,14 +48,9 @@ fn main() {
                         }
                         &_ => reader = "bat".to_string(),
                     }
-
                 } else {
                     provider = "glow".to_string();
                 }
-
-            } else {
-                provider = "gogo".to_string();
-
             }
             "--cast" | "-C" => {
                 if let Some(arg) = std::env::args().nth(count + 1) {
@@ -136,13 +131,13 @@ fn print_help() {
     );
     println!(
         "if no provider is entered it will default to {}",
-        "gogo".green()
+        "vrv".green()
     );
     println!(
         "if the -r argument is not used it will default to {}",
-        "zoro".green()
+        "gogo".green()
     );
-    println!("the providers are {} or {}", "gogoanime".green(), "zoro".green());
+    println!("the providers are {} or {}", "gogo".green(), "vrv".green());
     println!("");
     println!("reader:\t\t{}", format_args!("{}", "-R --reader".red()));
     println!(