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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
use crate::api::{DDApi, DDnetClient, HasApiCore};
use crate::error::Result;
use crate::scheme::ddnet::prelude::*;
use std::future::Future;
#[allow(dead_code)]
pub trait DDnetApi {
fn master(&self) -> impl Future<Output = Result<Master>> + Send;
fn skins(&self) -> impl Future<Output = Result<DDSkins>> + Send;
fn custom_master(&self, master: MasterServer) -> impl Future<Output = Result<Master>> + Send;
fn player(&self, player: &str) -> impl Future<Output = Result<Player>> + Send;
fn query(&self, player: &str) -> impl Future<Output = Result<Vec<Query>>> + Send;
fn query_map(&self, player: &str) -> impl Future<Output = Result<Vec<QueryMap>>> + Send;
fn query_mapper(&self, player: &str) -> impl Future<Output = Result<Vec<QueryMapper>>> + Send;
fn map(&self, map: &str) -> impl Future<Output = Result<Map>> + Send;
fn releases_map(&self) -> impl Future<Output = Result<Vec<ReleasesMaps>>> + Send;
fn status(&self) -> impl Future<Output = Result<Status>> + Send;
fn latest_finish(&self) -> impl Future<Output = Result<Vec<LatestFinishes>>> + Send;
fn latest_finish_with_latest(
&self,
latest: usize,
) -> impl Future<Output = Result<Vec<LatestFinishes>>> + Send;
}
impl DDnetApi for DDApi {
/// Fetches server list from the default master server
///
/// Returns a list of game servers from the primary master server (master1.ddnet.org).
///
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
///
/// let api = DDApi::new();
/// let master = api.master().await?;
/// println!("Found {} servers", master.servers.len());
/// ```
async fn master(&self) -> Result<Master> {
self.custom_master(MasterServer::One).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let skins: DDSkins = api.skins().await?;
/// println!("Found {} available skins", skins.skins.len());
/// for skin in skins.skins {
/// println!("Skin: {} by {}", skin.name, skin.creator);
/// }
/// ```
async fn skins(&self) -> Result<DDSkins> {
self._generator(&DDSkins::api()).await
}
/// Fetches server list from a specific master server
///
/// Allows selecting which master server to query. DDNet has multiple
/// master servers for redundancy and load distribution.
///
/// # Arguments
///
/// * `master` - The master server to query (`MasterServer::One`, `MasterServer::Two`, etc.)
///
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// // Use secondary master server as fallback
/// let master = api.custom_master(MasterServer::Two).await?;
/// ```
async fn custom_master(&self, master: MasterServer) -> Result<Master> {
self._generator_no_cache(&Master::api(master)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let player: Player = api.player("nameless tee").await?;
/// println!("{}: {}", player.player, player.points.points.unwrap_or(0));
/// ```
async fn player(&self, player: &str) -> Result<Player> {
self._generator(&Player::api(player)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let query: Vec<Query> = api.query("nameless tee").await?;
/// for player in &query {
/// println!("{}: {}", player.name, player.points);
/// }
/// ```
async fn query(&self, player: &str) -> Result<Vec<Query>> {
self._generator(&Query::api(player)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let query: Vec<QueryMap> = api.query_map("multi").await?;
/// for map in &query {
/// println!("{}: {} | {}", map.name, map.mapper, map.r#type);
/// }
/// ```
async fn query_map(&self, map: &str) -> Result<Vec<QueryMap>> {
self._generator(&QueryMap::api(map)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let query: Vec<QueryMapper> = api.query_mapper("Ao").await?;
/// for player in &query {
/// println!("{}: {}", player.mapper, player.num_maps);
/// }
/// ```
async fn query_mapper(&self, player: &str) -> Result<Vec<QueryMapper>> {
self._generator(&QueryMapper::api(player)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let map: Map = api.map("Fox").await?;
/// println!("{}: {}", map.mapper, map.web_preview);
/// ```
async fn map(&self, map: &str) -> Result<Map> {
self._generator(&Map::api(map)).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let maps: Vec<ReleasesMaps> = api.releases_map().await?;
/// for map in &maps {
/// println!("{}: {} | {}", map.name, map.mapper, map.r#type);
/// }
/// ```
async fn releases_map(&self) -> Result<Vec<ReleasesMaps>> {
self._generator_no_cache(&ReleasesMaps::api()).await
}
/// # Examples
///
/// ```rust,ignore
/// use ddapi_rs::prelude::*;
/// use ddapi_rs::prelude::ddnet::*;
///
/// let api = DDApi::new();
/// let status: Status = api.status().await?;
/// for data in &status.servers {
/// println!("{}: {} | {}", data.name, data.location, data.host);
/// }
/// ```
async fn status(&self) -> Result<Status> {
self._generator_no_cache(&Status::api()).await
}
async fn latest_finish(&self) -> Result<Vec<LatestFinishes>> {
self.latest_finish_with_latest(0).await
}
async fn latest_finish_with_latest(&self, latest: usize) -> Result<Vec<LatestFinishes>> {
self._generator_no_cache(&LatestFinishes::api(latest)).await
}
}
impl DDnetApi for DDnetClient {
async fn master(&self) -> Result<Master> {
self.custom_master(MasterServer::One).await
}
async fn skins(&self) -> Result<DDSkins> {
self.core()._generator(&DDSkins::api()).await
}
async fn custom_master(&self, master: MasterServer) -> Result<Master> {
self.core()._generator_no_cache(&Master::api(master)).await
}
async fn player(&self, player: &str) -> Result<Player> {
self.core()._generator(&Player::api(player)).await
}
async fn query(&self, player: &str) -> Result<Vec<Query>> {
self.core()._generator(&Query::api(player)).await
}
async fn query_map(&self, map: &str) -> Result<Vec<QueryMap>> {
self.core()._generator(&QueryMap::api(map)).await
}
async fn query_mapper(&self, player: &str) -> Result<Vec<QueryMapper>> {
self.core()._generator(&QueryMapper::api(player)).await
}
async fn map(&self, map: &str) -> Result<Map> {
self.core()._generator(&Map::api(map)).await
}
async fn releases_map(&self) -> Result<Vec<ReleasesMaps>> {
self.core()._generator_no_cache(&ReleasesMaps::api()).await
}
async fn status(&self) -> Result<Status> {
self.core()._generator_no_cache(&Status::api()).await
}
async fn latest_finish(&self) -> Result<Vec<LatestFinishes>> {
self.latest_finish_with_latest(0).await
}
async fn latest_finish_with_latest(&self, latest: usize) -> Result<Vec<LatestFinishes>> {
self.core()
._generator_no_cache(&LatestFinishes::api(latest))
.await
}
}