magnetease 0.3.1

A library to fetch magnets from the internet
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

use async_trait::async_trait;
use reqwest::Client;
use serde::{Deserialize, Serialize};

use crate::{Magnet, MagneteaseError, MagneteaseResult, Provider, WhichProvider};

const API_URL: &str = "https://api.knaben.org/v1";

pub struct Knaben;

#[async_trait]
impl Provider for Knaben {
    fn name(&self) -> &'static str {
        "Knaben"
    }

    fn display_url(&self) -> &'static str {
        "knaben.org"
    }

    async fn search(
        &self,
        client: &Client,
        query: &str,
    ) -> Result<MagneteaseResult, MagneteaseError> {
        let json_data = serde_json::json!({
            "search_type": "100%",
            "search_field": "title",
            "query": query,
            "order_by": "seeders",
            "order_direction": "desc",
            "size": 150
        })
        .to_string();

        let res = client
            .post(API_URL)
            .body(json_data)
            .header(reqwest::header::CONTENT_TYPE, "application/json")
            .send()
            .await
            .map_err(|e| MagneteaseError {
                kind: e.into(),
                provider: WhichProvider::Knaben,
            })?
            .json::<KnabenAPIResult>()
            .await
            .map_err(|e| MagneteaseError {
                kind: e.into(),
                provider: WhichProvider::Knaben,
            })?;

        let magnets = res
            .hits
            .into_iter()
            .filter_map(|x| Magnet::try_from(x).ok())
            .collect();

        Ok(MagneteaseResult {
            provider: WhichProvider::Knaben,
            magnets,
        })
    }
}

impl TryFrom<KnabenMagnet> for Magnet {
    type Error = ();

    fn try_from(value: KnabenMagnet) -> Result<Self, Self::Error> {
        match value {
            KnabenMagnet {
                title,
                magnet_url: Some(url),
                seeders,
                bytes,
            } => Ok(Self {
                title,
                url,
                seeders,
                bytes,
            }),
            _ => Err(()),
        }
    }
}

#[derive(Debug, Serialize, Deserialize)]
struct KnabenAPIResult {
    hits: Vec<KnabenMagnet>,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct KnabenMagnet {
    magnet_url: Option<String>,
    title: String,
    seeders: u32,
    bytes: u64,
}