Rustiny 0.1.12

A wrapper for the Destiny 2 / Bungie.net REST API
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
151
152
153
154
155

use std::borrow::Borrow;
use std::collections::HashMap;
use reqwest::{Client, Response};
use anyhow::Result;
use serde_json::Value;
use std::sync::atomic::AtomicBool;
use serde::de::DeserializeOwned;
use tokio::sync::Mutex;

pub struct ApiClient {
    pub(crate) apikey: String,
    DEBUG_MODE: Mutex<AtomicBool>,
}

impl ApiClient {
    pub fn new(apikey: &str) -> Self {
        Self {
            apikey: String::from(apikey),
            DEBUG_MODE: Mutex::new(AtomicBool::new(false)),
        }
    }

    /// Enables Debug Mode
    ///
    /// Prints all requests and their responses as they come through
    /// usually only needed for development of the API but may be useful
    /// to someone wanting to learn the inner-workings of the system.
    pub async fn enable_debug_mode(self) -> Self {
        let mut temp = self.DEBUG_MODE.lock().await;
        *temp = AtomicBool::new(true);
        drop(temp);
        self
    }

    pub async fn is_debug_enabled(&self) -> bool {
        *self.DEBUG_MODE.lock().await.get_mut()
    }

    /// Clones the ApiClient
    pub async fn clone(&self) -> Self {
        Self {
            apikey: self.apikey.clone(),
            DEBUG_MODE: Mutex::new(AtomicBool::new(self.is_debug_enabled().await)),
        }
    }

    pub async fn get(&self, url: String) -> Result<String> {
        self.get_params(url, HashMap::new()).await
    }

    pub async fn get_params(&self, url: String, map: HashMap<&str, &str>) -> Result<String> {
        let client = reqwest::Client::new();
        let resp = client
            .get(url.clone())
            .header("X-API-KEY", self.apikey.as_str())
            .query(&map)
            .send()
            .await?;

        let text = resp.text().await?;

        if self.is_debug_enabled().await {
            println!("GET {}", url);
            println!("{}", text.clone());
        }


        Ok(text)
    }

    pub async fn get_parse<T: DeserializeOwned>(&self, url: String, dewrap: bool) -> Result<T> {
        if dewrap {
            let val = serde_json::from_str::<Value>(self.get(url.clone()).await?.as_str())?;

            return Ok(serde_json::from_value::<T>(val["Response"].clone())?)
        }

        let text = self.get(url.clone()).await?;

        let r = serde_json::from_str::<T>(text.as_str())?;

        Ok(r)
    }

    pub async fn get_parse_params<T: DeserializeOwned>(&self, url: String, dewrap: bool, map: HashMap<&str, &str>) -> Result<T> {
        if dewrap {
            let val = serde_json::from_str::<Value>(self.get_params(url.clone(), map).await?.as_str())?;

            return Ok(serde_json::from_value::<T>(val["Response"].clone())?)
        }

        let text = self.get_params(url, map).await?;

        Ok(serde_json::from_str::<T>(text.as_str())?)
    }

    pub async fn post(&self, url: String, body: String) -> Result<String> {
        self.post_params(url, body, HashMap::new()).await
    }

    pub async fn post_params(&self, url: String, body: String, map: HashMap<&str, &str>) -> Result<String> {
        let client = Client::new();
        let resp = client
            .post(url.clone())
            .body(body.clone())
            .header("X-API-KEY", self.apikey.as_str())
            .query(&map)
            .send()
            .await?;

        let text = resp.text().await?;

        if self.is_debug_enabled().await {
            println!("POST {}", url);
            println!("Body - {}", body);
            println!("{}", text.clone());
        }

        Ok(text)
    }

    pub async fn post_parse<T: DeserializeOwned>(&self, url: String, body: String, dewrap: bool) -> Result<T> {
        if dewrap {
            let val = serde_json::from_str::<Value>(self.post(url, body).await?.as_str())?;

            return Ok(serde_json::from_value::<T>(val["Response"].clone())?)
        }

        let text = self.post(url, body).await?;

        let r = serde_json::from_str::<T>(text.as_str())?;

        Ok(r)
    }

    pub async fn post_parse_params<T: DeserializeOwned>(&self, url: String, body: String, map: HashMap<&str, &str>, dewrap: bool) -> Result<T> {
        if dewrap {
            let val = serde_json::from_str::<Value>(self.post_params(url, body, map).await?.as_str())?;

            return Ok(serde_json::from_value::<T>(val["Response"].clone())?)
        }

        let text = self.post_params(url, body, map).await?;

        Ok(serde_json::from_str::<T>(text.as_str())?)
    }
}

pub trait HandleValue {
    fn handle(value: Value) -> Value;
}

fn encode_url(url: String) -> String {
    url.replace(" ", "%20")
}