ifpaclient 0.1.0

Async Rust client for the IFPA Pinball 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
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
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325

use serde::{Deserialize, Serialize};

use super::common::{DistanceUnit, EventType, RankType};

// GET /tournament/formats

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentFormatsResponse {
    pub qualifying_formats: Vec<Format>,
    pub finals_formats: Vec<Format>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct Format {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub format_id: i64,
    pub name: String,
    pub description: String,
}

// GET /tournament/{id}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct Tournament {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub tournament_id: i64,
    pub tournament_name: String,
    pub tournament_type: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub private_flag: bool,
    pub address1: String,
    pub address2: String,
    pub city: String,
    pub stateprov: String,
    pub postal_code: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub latitude: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub longitude: f64,
    pub country_name: String,
    pub country_code: String,
    pub raw_address: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub director_id: i64,
    pub director_name: String,
    pub website: String,
    pub profile_photo: Option<String>,
    pub event_name: String,
    pub event_start_date: String,
    pub event_end_date: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub ratings_strength: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub rankings_strength: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub base_value: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub tournament_percentage_grade: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub tournament_value: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub qualify_flag: bool,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub qualify_hours: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub unlimited_qualify_flag: bool,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub eligible_player_count: i64,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_count: i64,
    pub ranking_system: String,
    pub details: String,
    pub qualifying_format: String,
    pub finals_format: String,
    #[serde(
        deserialize_with = "crate::serde_util::optional_string_or_i64",
        default
    )]
    pub player_limit: Option<i64>,
    pub registration_date: Option<String>,
    #[serde(
        deserialize_with = "crate::serde_util::optional_string_or_i64",
        default
    )]
    pub matchplay_id: Option<i64>,
}

// GET /tournament/{id}/related

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct RelatedTournamentsResponse {
    pub tournament: Vec<RelatedTournament>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct RelatedTournament {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub tournament_id: i64,
    pub tournament_name: String,
    pub tournament_type: String,
    pub event_name: String,
    pub event_start_date: String,
    pub event_end_date: String,
    pub ranking_system: String,
    pub winner: Option<RelatedTournamentWinner>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct RelatedTournamentWinner {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_id: i64,
    pub name: String,
    pub country_name: String,
    pub country_code: String,
}

// GET /tournament/{id}/results

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentResultsResponse {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub tournament_id: i64,
    pub ranking_system: String,
    pub results: Vec<TournamentResult>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentResult {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_id: i64,
    pub name: String,
    pub profile_photo: Option<String>,
    pub country_name: String,
    pub country_code: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub position: i64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub points: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub wppr_rank: i64,
    pub ratings_value: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub excluded_flag: bool,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_tournament_count: i64,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub wppr_pro_rank: i64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub efficiency_value: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub post_rank_pos: i64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub post_rating_value: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub post_efficiency_value: f64,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub post_wppr_pro_rank: i64,
}

// GET /tournament/leagues/{time_period}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct LeaguesResponse {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub total_entries: i64,
    pub status: String,
    pub results: Vec<LeagueEntry>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct LeagueEntry {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub tournament_id: i64,
    pub tournament_name: String,
    pub event_name: String,
    pub city: String,
    pub stateprov: String,
    pub country_name: String,
    pub country_code: String,
    pub latitude: String,
    pub longitude: String,
    pub event_start_date: String,
    pub event_end_date: serde_json::Value,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub private_flag: bool,
    pub director_name: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub director_id: i64,
}

// GET /tournament/search

#[derive(Debug, Clone, Default, Serialize)]
pub struct TournamentSearchParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stateprov: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rank_type: Option<RankType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_type: Option<EventType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(
        deserialize_with = "crate::serde_util::optional_string_or_i64",
        default
    )]
    pub start_pos: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(
        deserialize_with = "crate::serde_util::optional_string_or_i64",
        default
    )]
    pub total: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub director_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pre_registration: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub only_with_results: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub radius: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub distance_unit: Option<DistanceUnit>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min_points: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_points: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub point_filter: Option<String>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentSearchResponse {
    pub search_filter: TournamentSearchFilter,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub total_results: i64,
    pub tournaments: Vec<TournamentSearchResult>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentSearchFilter {
    pub name: Option<String>,
    pub country: Option<String>,
    pub stateprov: Option<String>,
    pub start_date: Option<String>,
    pub end_date: Option<String>,
    pub rank_type: Option<String>,
    pub sort_mode: Option<String>,
    pub sort_order: Option<String>,
    pub director_name: Option<String>,
    pub event_type: Option<String>,
    pub distance_unit: Option<serde_json::Value>,
    pub radius: Option<serde_json::Value>,
    pub latitude: Option<String>,
    pub longitude: Option<String>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct TournamentSearchResult {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub tournament_id: i64,
    pub tournament_name: String,
    pub event_name: String,
    pub event_type: String,
    pub address1: String,
    pub city: String,
    pub stateprov: String,
    pub country_name: String,
    pub country_code: String,
    pub event_start_date: String,
    pub event_end_date: String,
    pub latitude: String,
    pub longitude: String,
    pub raw_address: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub private_flag: bool,
    pub ranking_system: String,
    pub preregistration_date: Option<String>,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_count: i64,
    pub qualifying_format: String,
    pub finals_format: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub director_id: i64,
    pub director_name: String,
    pub website: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_bool", default)]
    pub certified_flag: bool,
    pub winner: Option<SearchWinner>,
}

#[derive(Debug, Clone, Default, Deserialize)]
#[serde(default)]
pub struct SearchWinner {
    #[serde(deserialize_with = "crate::serde_util::string_or_i64", default)]
    pub player_id: i64,
    pub player_name: String,
    #[serde(deserialize_with = "crate::serde_util::string_or_f64", default)]
    pub wppr_points: f64,
    pub profile_photo: Option<String>,
}