napchart 0.1.3-alpha

Rust interface for the https://napchart.com API alpha
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

/*
 * --------------------
 * THIS FILE IS LICENSED UNDER MIT
 * THE FOLLOWING MESSAGE IS NOT A LICENSE
 *
 * <barrow@tilde.team> wrote this file.
 * by reading this text, you are reading "TRANS RIGHTS".
 * this file and the content within it is the gay agenda.
 * if we meet some day, and you think this stuff is worth it,
 * you can buy me a beer, tea, or something stronger.
 * -Ezra Barrow
 * --------------------
 */

//! The actual api clients
//!
//! if the "async" feature is enabled, then you can use napchart::api::AsyncClient  
//! if the "blocking" feature is enabled, then you can use napchart::api::BlockingClient

use crate::error::*;
use crate::raw;
use crate::Napchart;
use serde::Deserialize;
use std::convert::{TryFrom, TryInto};

#[derive(Deserialize)]
struct CreateResponse {
    chartid: String,
}

#[cfg(feature = "async")]
/// Asynchronous api client for <https://napchart.com>
pub struct AsyncClient {
    internal: reqwest::Client,
}
#[cfg(feature = "async")]
impl AsyncClient {
    /// Asynchronously downloads the napchart with the given id from napchart.com
    ///
    /// Uses the <https://thumb.napchart.com/api/get> endpoint
    pub async fn get<'a, T: Into<&'a str>>(&self, chartid: T) -> Result<Napchart> {
        self.internal
            .get(format!(
                "https://thumb.napchart.com/api/get?chartid={}",
                chartid.into()
            ))
            .send()
            .await?
            .json::<raw::Napchart>()
            .await?
            .try_into()
    }
    /// Asynchronously creates a napchart on napchart.com and returns its id
    ///
    /// Uses the <https://thumb.napchart.com/alt/api/create> endpoint
    pub async fn create(&self, chart: &Napchart) -> Result<String> {
        Ok(self
            .internal
            .post("https://thumb.napchart.com/alt/api/create")
            .json(&raw::Napchart::try_from(chart.clone())?.as_uploadable())
            .send()
            .await?
            .json::<CreateResponse>()
            .await?
            .chartid)
    }
    /// Asynchronously creates a napchart on napchart.com and sets the chartid of the napchart
    /// struct to the assigned id
    ///
    /// Uses the <https://thumb.napchart.com/alt/api/create> endpoint
    pub async fn create_new(&self, chart: &mut Napchart) -> Result<()> {
        chart.chartid = Some(self.create(chart).await?);
        Ok(())
    }
}
#[cfg(feature = "async")]
impl Default for AsyncClient {
    fn default() -> Self {
        Self {
            internal: reqwest::Client::new(),
        }
    }
}

#[cfg(feature = "blocking")]
/// Synchronous api client for <https://napchart.com>
pub struct BlockingClient {
    internal: reqwest::blocking::Client,
}
impl BlockingClient {
    /// Synchronously downloads the napchart with the given id from napchart.com
    ///
    /// Uses the <https://thumb.napchart.com/api/get> endpoint
    pub fn get<'a, T: Into<&'a str>>(&self, chartid: T) -> Result<Napchart> {
        self.internal
            .get(format!(
                "https://thumb.napchart.com/api/get?chartid={}",
                chartid.into()
            ))
            .send()?
            .json::<raw::Napchart>()?
            .try_into()
    }
    /// Synchronously creates a napchart on napchart.com and returns its id
    ///
    /// Uses the <https://thumb.napchart.com/alt/api/create> endpoint
    pub fn create(&self, chart: &Napchart) -> Result<String> {
        Ok(self
            .internal
            .post("https://thumb.napchart.com/alt/api/create")
            .json(&raw::Napchart::try_from(chart.clone())?.as_uploadable())
            .send()?
            .json::<CreateResponse>()?
            .chartid)
    }
    /// Synchronously creates a napchart on napchart.com and sets the chartid of the napchart
    /// struct to the assigned id
    ///
    /// Uses the <https://thumb.napchart.com/alt/api/create> endpoint
    pub fn create_new(&self, chart: &mut Napchart) -> Result<()> {
        chart.chartid = Some(self.create(chart)?);
        Ok(())
    }
}
impl Default for BlockingClient {
    fn default() -> Self {
        BlockingClient {
            internal: reqwest::blocking::Client::new(),
        }
    }
}