1pub mod blocking;
2pub mod model;
3
4const BASE_URL: &str = "https://koreanbots.dev/api/v2";
5
6use std::collections::HashMap;
7
8use model::UserInfo;
9use reqwest::{
10 header::HeaderMap,
11 header::{AUTHORIZATION, CONTENT_TYPE},
12 Url,
13};
14
15use crate::model::{
16 response::{Data, Response, ResponseUpdate},
17 Bot, VoteCheck, WidgetQuery, WidgetType,
18};
19
20pub struct Client {
21 authorization: &'static str,
22}
23
24impl Client {
25 pub fn new(authorization: &'static str) -> Self {
26 Self { authorization }
27 }
28
29 pub async fn get_bot(&self, bot_id: &str) -> Response<Bot> {
30 let mut url = String::from("bots/");
31 url.push_str(bot_id);
32 let fetch = Client::_fetch("GET", &url, None, None, None);
33 let json: Response<Bot> = serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
34
35 json
36 }
37
38 pub async fn search_bot(&self, search: &str, page: Option<usize>) -> Response<Data<Bot>> {
39 let mut query = HashMap::new();
40 query.insert("query", search.to_string());
41 if let Some(page) = page {
42 query.insert("page", page.to_string());
43 } else {
44 query.insert("page", "1".to_string());
45 }
46 let fetch = Client::_fetch("GET", "search/bots", None, Some(query), None);
47
48 let json: Response<Data<Bot>> =
49 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
50
51 json
52 }
53
54 pub async fn get_votes_list(&self, page: Option<usize>) -> Response<Data<Bot>> {
55 let mut query = HashMap::new();
56 if let Some(page) = page {
57 query.insert("page", page.to_string());
58 } else {
59 query.insert("page", "1".to_string());
60 }
61 let fetch = Client::_fetch("GET", "list/bots/votes", None, Some(query), None);
62
63 let json: Response<Data<Bot>> =
64 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
65
66 json
67 }
68
69 pub async fn get_new_bot_list(&self) -> Response<Data<Bot>> {
70 let fetch = Client::_fetch("GET", "list/bots/new", None, None, None);
71
72 let json: Response<Data<Bot>> =
73 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
74
75 json
76 }
77
78 pub async fn get_vote_check(&self, bot_id: &str, user_id: &str) -> Response<VoteCheck> {
79 let mut header = HeaderMap::new();
80 header.insert(AUTHORIZATION, self.authorization.parse().unwrap());
81 header.insert(CONTENT_TYPE, "application/json".parse().unwrap());
82 let mut query = HashMap::new();
83 query.insert("userID", user_id.to_string());
84 let mut url = String::from("bots/");
85 url.push_str(bot_id);
86 url.push_str("/vote");
87
88 let fetch = Client::_fetch("GET", &url, Some(header), Some(query), None);
89
90 let json: Response<VoteCheck> =
91 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
92
93 json
94 }
95
96 pub async fn update(
97 &self,
98 bot_id: &str,
99 servers: Option<usize>,
100 shards: Option<usize>,
101 ) -> ResponseUpdate {
102 let mut header = HeaderMap::new();
103 header.insert(AUTHORIZATION, self.authorization.parse().unwrap());
104 header.insert(CONTENT_TYPE, "application/json".parse().unwrap());
105
106 let mut json = HashMap::new();
107 if let Some(servers) = servers {
108 json.insert("servers", servers.to_string());
109 } else if let Some(shards) = shards {
110 json.insert("shards", shards.to_string());
111 }
112
113 let mut url = String::from("bots/");
114 url.push_str(bot_id);
115 url.push_str("/stats");
116
117 let fetch = Client::_fetch("POST", &url, Some(header), None, Some(json));
118
119 let json: ResponseUpdate =
120 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
121
122 json
123 }
124
125 pub async fn get_user(&self, user_id: &str) -> Response<UserInfo> {
126 let mut url = String::from("users/");
127 url.push_str(user_id);
128
129 let fetch = Client::_fetch("GET", &url, None, None, None);
130 let json: Response<UserInfo> =
131 serde_json::from_str(&fetch.await.text().await.unwrap()).unwrap();
132
133 json
134 }
135
136 pub async fn get_bot_widget(
137 &self,
138 bot_id: &str,
139 widget_type: WidgetType,
140 widget_query: Option<WidgetQuery>,
141 ) -> String {
142 let query = {
143 if let Some(widget_query) = widget_query {
144 let mut query: HashMap<&str, String> = HashMap::new();
145 query.insert("style", widget_query.to_style().to_string());
146 query.insert("icon", widget_query.to_icon().to_string());
147 query.insert("scale", widget_query.to_scale().to_string());
148
149 Some(query)
150 } else {
151 None
152 }
153 };
154 let mut url = String::from("widget/bots/");
155 url.push_str(&widget_type.to_string());
156 url.push('/');
157 url.push_str(bot_id);
158 url.push_str(".svg");
159
160 let fetch = Client::_fetch("GET", &url, None, query, None);
161
162 fetch.await.url().to_string()
163 }
164
165 async fn _fetch(
166 method: &str,
167 path: &str,
168 headers: Option<HeaderMap>,
169 query: Option<HashMap<&str, String>>,
170 json: Option<HashMap<&str, String>>,
171 ) -> reqwest::Response {
172 let client = reqwest::Client::new();
173 let url = {
174 let path_url = format!("{}/{}", BASE_URL, path);
175 if let Some(query) = query {
176 Url::parse_with_params(&path_url, query)
177 .unwrap()
178 .to_string()
179 } else {
180 path_url
181 }
182 };
183
184 match method {
185 "GET" => {
186 if let Some(headers) = headers {
187 if let Some(json) = json {
188 client
189 .get(url)
190 .headers(headers)
191 .json(&json)
192 .send()
193 .await
194 .unwrap()
195 } else {
196 client.get(url).headers(headers).send().await.unwrap()
197 }
198 } else if let Some(json) = json {
199 client.get(url).json(&json).send().await.unwrap()
200 } else {
201 client.get(url).send().await.unwrap()
202 }
203 }
204 "POST" => {
205 if let Some(headers) = headers {
206 if let Some(json) = json {
207 client
208 .post(url)
209 .headers(headers)
210 .json(&json)
211 .send()
212 .await
213 .unwrap()
214 } else {
215 client.post(url).headers(headers).send().await.unwrap()
216 }
217 } else if let Some(json) = json {
218 client.post(url).json(&json).send().await.unwrap()
219 } else {
220 client.post(url).send().await.unwrap()
221 }
222 }
223 _ => panic!(""),
224 }
225 }
226}