nyaa 0.9.1

A tui tool for browsing and downloading torrents from nyaa.si
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

use std::{error::Error, fs, path::PathBuf};

use reqwest::StatusCode;
use serde::{Deserialize, Serialize};

use crate::{source::Item, util::conv::get_hash};

use super::{multidownload, ClientConfig, DownloadClient, DownloadError, DownloadResult};

#[derive(Serialize, Deserialize, Clone)]
#[serde(default)]
pub struct DownloadConfig {
    save_dir: String,
    filename: Option<String>,
    overwrite: bool,
    create_root_folder: bool,
}

pub struct DownloadFileClient;

impl Default for DownloadConfig {
    fn default() -> Self {
        let download_dir = match dirs::download_dir() {
            Some(p) => p,
            None => match dirs::home_dir() {
                Some(h) => h.join("Downloads"),
                None => PathBuf::from("./"),
            },
        };
        DownloadConfig {
            save_dir: download_dir.to_string_lossy().to_string(),
            filename: None,
            overwrite: true,
            create_root_folder: true,
        }
    }
}

pub fn load_config(cfg: &mut ClientConfig) {
    if cfg.download.is_none() {
        cfg.download = Some(DownloadConfig::default());
    }
}

async fn download_torrent(
    torrent_link: String,
    filename: String,
    save_dir: String,
    create_root_folder: bool,
    overwrite: bool,
    client: reqwest::Client,
) -> Result<String, Box<dyn Error>> {
    let response = client.get(torrent_link.to_owned()).send().await?;
    if response.status() != StatusCode::OK {
        // Throw error if response code is not OK
        let code = response.status().as_u16();
        return Err(format!("{}\nInvalid response code: {}", torrent_link, code).into());
    }
    let content = response.bytes().await?;
    let folder = PathBuf::from(shellexpand::full(&save_dir)?.to_string());
    let filepath = folder.join(filename);
    if !overwrite && filepath.exists() {
        return Err(format!(
            "{} already exists.\nEnable \"overwrite\" to overwrite files",
            filepath.to_string_lossy()
        )
        .into());
    }
    if create_root_folder && !folder.exists() {
        fs::create_dir_all(folder)?;
    }
    fs::write(filepath.clone(), content)?;
    Ok(filepath.to_string_lossy().to_string())
}

impl DownloadClient for DownloadFileClient {
    async fn download(item: Item, conf: ClientConfig, client: reqwest::Client) -> DownloadResult {
        let conf = match conf.download.to_owned() {
            Some(c) => c,
            None => {
                return DownloadResult::error(DownloadError(
                    "Failed to get download config".to_owned(),
                ));
            }
        };

        // TODO: Substitutions
        let filename = conf
            .filename
            .map(|f| {
                f.replace("{file}", &item.file_name)
                    .replace(
                        "{basename}",
                        item.file_name
                            .split_once(".torrent")
                            .map(|f| f.0)
                            .unwrap_or(&item.file_name),
                    )
                    .replace(
                        "{hash}",
                        &get_hash(item.magnet_link).unwrap_or("NO_HASH_FOUND".to_string()),
                    )
            })
            .unwrap_or(item.file_name.to_owned());
        let (success_msg, success_ids, errors) = match download_torrent(
            item.torrent_link.to_owned(),
            filename,
            conf.save_dir.clone(),
            conf.create_root_folder,
            conf.overwrite,
            client,
        )
        .await
        {
            Ok(path) => (
                Some(format!("Saved to \"{}\"", path)),
                vec![item.id],
                vec![],
            ),
            Err(e) => (
                None,
                vec![],
                vec![DownloadError(
                    format!(
                        "Failed to download torrent to {}:\n{}",
                        conf.save_dir.to_owned(),
                        e
                    )
                    .to_owned(),
                )],
            ),
        };
        DownloadResult::new(success_msg, success_ids, errors, false)
    }

    async fn batch_download(
        items: Vec<Item>,
        conf: ClientConfig,
        client: reqwest::Client,
    ) -> DownloadResult {
        let save_dir = conf.download.clone().unwrap_or_default().save_dir.clone();
        multidownload::<DownloadFileClient, _>(
            |s| format!("Saved {} torrents to folder {}", s, save_dir),
            &items,
            &conf,
            &client,
        )
        .await
    }
}