1use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum GetDistrictEventsError {
22 Status401(),
23 UnknownValue(serde_json::Value),
24}
25
26#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(untagged)]
29pub enum GetDistrictEventsKeysError {
30 Status401(),
31 UnknownValue(serde_json::Value),
32}
33
34#[derive(Debug, Clone, Serialize, Deserialize)]
36#[serde(untagged)]
37pub enum GetDistrictEventsSimpleError {
38 Status401(),
39 UnknownValue(serde_json::Value),
40}
41
42#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum GetDistrictRankingsError {
46 Status401(),
47 UnknownValue(serde_json::Value),
48}
49
50#[derive(Debug, Clone, Serialize, Deserialize)]
52#[serde(untagged)]
53pub enum GetDistrictTeamsError {
54 Status401(),
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum GetDistrictTeamsKeysError {
62 Status401(),
63 UnknownValue(serde_json::Value),
64}
65
66#[derive(Debug, Clone, Serialize, Deserialize)]
68#[serde(untagged)]
69pub enum GetDistrictTeamsSimpleError {
70 Status401(),
71 UnknownValue(serde_json::Value),
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum GetEventTeamsError {
78 Status401(),
79 UnknownValue(serde_json::Value),
80}
81
82#[derive(Debug, Clone, Serialize, Deserialize)]
84#[serde(untagged)]
85pub enum GetEventTeamsKeysError {
86 Status401(),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum GetEventTeamsSimpleError {
94 Status401(),
95 UnknownValue(serde_json::Value),
96}
97
98#[derive(Debug, Clone, Serialize, Deserialize)]
100#[serde(untagged)]
101pub enum GetEventTeamsStatusesError {
102 Status401(),
103 UnknownValue(serde_json::Value),
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
108#[serde(untagged)]
109pub enum GetEventsByYearError {
110 Status401(),
111 UnknownValue(serde_json::Value),
112}
113
114#[derive(Debug, Clone, Serialize, Deserialize)]
116#[serde(untagged)]
117pub enum GetEventsByYearKeysError {
118 Status401(),
119 UnknownValue(serde_json::Value),
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize)]
124#[serde(untagged)]
125pub enum GetEventsByYearSimpleError {
126 Status401(),
127 UnknownValue(serde_json::Value),
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum GetTeamEventsStatusesByYearError {
134 Status401(),
135 UnknownValue(serde_json::Value),
136}
137
138#[derive(Debug, Clone, Serialize, Deserialize)]
140#[serde(untagged)]
141pub enum GetTeamsError {
142 Status401(),
143 UnknownValue(serde_json::Value),
144}
145
146#[derive(Debug, Clone, Serialize, Deserialize)]
148#[serde(untagged)]
149pub enum GetTeamsByYearError {
150 Status401(),
151 UnknownValue(serde_json::Value),
152}
153
154#[derive(Debug, Clone, Serialize, Deserialize)]
156#[serde(untagged)]
157pub enum GetTeamsByYearKeysError {
158 Status401(),
159 UnknownValue(serde_json::Value),
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
164#[serde(untagged)]
165pub enum GetTeamsByYearSimpleError {
166 Status401(),
167 UnknownValue(serde_json::Value),
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize)]
172#[serde(untagged)]
173pub enum GetTeamsKeysError {
174 Status401(),
175 UnknownValue(serde_json::Value),
176}
177
178#[derive(Debug, Clone, Serialize, Deserialize)]
180#[serde(untagged)]
181pub enum GetTeamsSimpleError {
182 Status401(),
183 UnknownValue(serde_json::Value),
184}
185
186
187pub async fn get_district_events(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::Event>, Error<GetDistrictEventsError>> {
189 let local_var_configuration = configuration;
190
191 let local_var_client = &local_var_configuration.client;
192
193 let local_var_uri_str = format!("{}/district/{district_key}/events", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
194 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
195
196 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
197 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
198 }
199 if let Some(local_var_param_value) = if_none_match {
200 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
201 }
202 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
203 let local_var_key = local_var_apikey.key.clone();
204 let local_var_value = match local_var_apikey.prefix {
205 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
206 None => local_var_key,
207 };
208 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
209 };
210
211 let local_var_req = local_var_req_builder.build()?;
212 let local_var_resp = local_var_client.execute(local_var_req).await?;
213
214 let local_var_status = local_var_resp.status();
215 let local_var_content = local_var_resp.text().await?;
216
217 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
218 serde_json::from_str(&local_var_content).map_err(Error::from)
219 } else {
220 let local_var_entity: Option<GetDistrictEventsError> = serde_json::from_str(&local_var_content).ok();
221 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
222 Err(Error::ResponseError(local_var_error))
223 }
224}
225
226pub async fn get_district_events_keys(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetDistrictEventsKeysError>> {
228 let local_var_configuration = configuration;
229
230 let local_var_client = &local_var_configuration.client;
231
232 let local_var_uri_str = format!("{}/district/{district_key}/events/keys", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
233 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
234
235 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
236 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
237 }
238 if let Some(local_var_param_value) = if_none_match {
239 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
240 }
241 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
242 let local_var_key = local_var_apikey.key.clone();
243 let local_var_value = match local_var_apikey.prefix {
244 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
245 None => local_var_key,
246 };
247 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
248 };
249
250 let local_var_req = local_var_req_builder.build()?;
251 let local_var_resp = local_var_client.execute(local_var_req).await?;
252
253 let local_var_status = local_var_resp.status();
254 let local_var_content = local_var_resp.text().await?;
255
256 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
257 serde_json::from_str(&local_var_content).map_err(Error::from)
258 } else {
259 let local_var_entity: Option<GetDistrictEventsKeysError> = serde_json::from_str(&local_var_content).ok();
260 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
261 Err(Error::ResponseError(local_var_error))
262 }
263}
264
265pub async fn get_district_events_simple(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::EventSimple>, Error<GetDistrictEventsSimpleError>> {
267 let local_var_configuration = configuration;
268
269 let local_var_client = &local_var_configuration.client;
270
271 let local_var_uri_str = format!("{}/district/{district_key}/events/simple", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
272 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
273
274 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
275 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
276 }
277 if let Some(local_var_param_value) = if_none_match {
278 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
279 }
280 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
281 let local_var_key = local_var_apikey.key.clone();
282 let local_var_value = match local_var_apikey.prefix {
283 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
284 None => local_var_key,
285 };
286 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
287 };
288
289 let local_var_req = local_var_req_builder.build()?;
290 let local_var_resp = local_var_client.execute(local_var_req).await?;
291
292 let local_var_status = local_var_resp.status();
293 let local_var_content = local_var_resp.text().await?;
294
295 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
296 serde_json::from_str(&local_var_content).map_err(Error::from)
297 } else {
298 let local_var_entity: Option<GetDistrictEventsSimpleError> = serde_json::from_str(&local_var_content).ok();
299 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
300 Err(Error::ResponseError(local_var_error))
301 }
302}
303
304pub async fn get_district_rankings(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::DistrictRanking>, Error<GetDistrictRankingsError>> {
306 let local_var_configuration = configuration;
307
308 let local_var_client = &local_var_configuration.client;
309
310 let local_var_uri_str = format!("{}/district/{district_key}/rankings", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
311 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
312
313 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
314 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
315 }
316 if let Some(local_var_param_value) = if_none_match {
317 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
318 }
319 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
320 let local_var_key = local_var_apikey.key.clone();
321 let local_var_value = match local_var_apikey.prefix {
322 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
323 None => local_var_key,
324 };
325 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
326 };
327
328 let local_var_req = local_var_req_builder.build()?;
329 let local_var_resp = local_var_client.execute(local_var_req).await?;
330
331 let local_var_status = local_var_resp.status();
332 let local_var_content = local_var_resp.text().await?;
333
334 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
335 serde_json::from_str(&local_var_content).map_err(Error::from)
336 } else {
337 let local_var_entity: Option<GetDistrictRankingsError> = serde_json::from_str(&local_var_content).ok();
338 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
339 Err(Error::ResponseError(local_var_error))
340 }
341}
342
343pub async fn get_district_teams(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::Team>, Error<GetDistrictTeamsError>> {
345 let local_var_configuration = configuration;
346
347 let local_var_client = &local_var_configuration.client;
348
349 let local_var_uri_str = format!("{}/district/{district_key}/teams", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
350 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
351
352 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
353 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
354 }
355 if let Some(local_var_param_value) = if_none_match {
356 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
357 }
358 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
359 let local_var_key = local_var_apikey.key.clone();
360 let local_var_value = match local_var_apikey.prefix {
361 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
362 None => local_var_key,
363 };
364 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
365 };
366
367 let local_var_req = local_var_req_builder.build()?;
368 let local_var_resp = local_var_client.execute(local_var_req).await?;
369
370 let local_var_status = local_var_resp.status();
371 let local_var_content = local_var_resp.text().await?;
372
373 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
374 serde_json::from_str(&local_var_content).map_err(Error::from)
375 } else {
376 let local_var_entity: Option<GetDistrictTeamsError> = serde_json::from_str(&local_var_content).ok();
377 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
378 Err(Error::ResponseError(local_var_error))
379 }
380}
381
382pub async fn get_district_teams_keys(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetDistrictTeamsKeysError>> {
384 let local_var_configuration = configuration;
385
386 let local_var_client = &local_var_configuration.client;
387
388 let local_var_uri_str = format!("{}/district/{district_key}/teams/keys", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
389 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
390
391 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
392 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
393 }
394 if let Some(local_var_param_value) = if_none_match {
395 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
396 }
397 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
398 let local_var_key = local_var_apikey.key.clone();
399 let local_var_value = match local_var_apikey.prefix {
400 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
401 None => local_var_key,
402 };
403 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
404 };
405
406 let local_var_req = local_var_req_builder.build()?;
407 let local_var_resp = local_var_client.execute(local_var_req).await?;
408
409 let local_var_status = local_var_resp.status();
410 let local_var_content = local_var_resp.text().await?;
411
412 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
413 serde_json::from_str(&local_var_content).map_err(Error::from)
414 } else {
415 let local_var_entity: Option<GetDistrictTeamsKeysError> = serde_json::from_str(&local_var_content).ok();
416 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
417 Err(Error::ResponseError(local_var_error))
418 }
419}
420
421pub async fn get_district_teams_simple(configuration: &configuration::Configuration, district_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::TeamSimple>, Error<GetDistrictTeamsSimpleError>> {
423 let local_var_configuration = configuration;
424
425 let local_var_client = &local_var_configuration.client;
426
427 let local_var_uri_str = format!("{}/district/{district_key}/teams/simple", local_var_configuration.base_path, district_key=crate::apis::urlencode(district_key));
428 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
429
430 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
431 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
432 }
433 if let Some(local_var_param_value) = if_none_match {
434 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
435 }
436 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
437 let local_var_key = local_var_apikey.key.clone();
438 let local_var_value = match local_var_apikey.prefix {
439 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
440 None => local_var_key,
441 };
442 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
443 };
444
445 let local_var_req = local_var_req_builder.build()?;
446 let local_var_resp = local_var_client.execute(local_var_req).await?;
447
448 let local_var_status = local_var_resp.status();
449 let local_var_content = local_var_resp.text().await?;
450
451 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
452 serde_json::from_str(&local_var_content).map_err(Error::from)
453 } else {
454 let local_var_entity: Option<GetDistrictTeamsSimpleError> = serde_json::from_str(&local_var_content).ok();
455 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
456 Err(Error::ResponseError(local_var_error))
457 }
458}
459
460pub async fn get_event_teams(configuration: &configuration::Configuration, event_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::Team>, Error<GetEventTeamsError>> {
462 let local_var_configuration = configuration;
463
464 let local_var_client = &local_var_configuration.client;
465
466 let local_var_uri_str = format!("{}/event/{event_key}/teams", local_var_configuration.base_path, event_key=crate::apis::urlencode(event_key));
467 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
468
469 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
470 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
471 }
472 if let Some(local_var_param_value) = if_none_match {
473 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
474 }
475 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
476 let local_var_key = local_var_apikey.key.clone();
477 let local_var_value = match local_var_apikey.prefix {
478 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
479 None => local_var_key,
480 };
481 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
482 };
483
484 let local_var_req = local_var_req_builder.build()?;
485 let local_var_resp = local_var_client.execute(local_var_req).await?;
486
487 let local_var_status = local_var_resp.status();
488 let local_var_content = local_var_resp.text().await?;
489
490 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
491 serde_json::from_str(&local_var_content).map_err(Error::from)
492 } else {
493 let local_var_entity: Option<GetEventTeamsError> = serde_json::from_str(&local_var_content).ok();
494 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
495 Err(Error::ResponseError(local_var_error))
496 }
497}
498
499pub async fn get_event_teams_keys(configuration: &configuration::Configuration, event_key: &str, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetEventTeamsKeysError>> {
501 let local_var_configuration = configuration;
502
503 let local_var_client = &local_var_configuration.client;
504
505 let local_var_uri_str = format!("{}/event/{event_key}/teams/keys", local_var_configuration.base_path, event_key=crate::apis::urlencode(event_key));
506 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
507
508 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
509 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
510 }
511 if let Some(local_var_param_value) = if_none_match {
512 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
513 }
514 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
515 let local_var_key = local_var_apikey.key.clone();
516 let local_var_value = match local_var_apikey.prefix {
517 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
518 None => local_var_key,
519 };
520 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
521 };
522
523 let local_var_req = local_var_req_builder.build()?;
524 let local_var_resp = local_var_client.execute(local_var_req).await?;
525
526 let local_var_status = local_var_resp.status();
527 let local_var_content = local_var_resp.text().await?;
528
529 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
530 serde_json::from_str(&local_var_content).map_err(Error::from)
531 } else {
532 let local_var_entity: Option<GetEventTeamsKeysError> = serde_json::from_str(&local_var_content).ok();
533 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
534 Err(Error::ResponseError(local_var_error))
535 }
536}
537
538pub async fn get_event_teams_simple(configuration: &configuration::Configuration, event_key: &str, if_none_match: Option<&str>) -> Result<Vec<crate::models::TeamSimple>, Error<GetEventTeamsSimpleError>> {
540 let local_var_configuration = configuration;
541
542 let local_var_client = &local_var_configuration.client;
543
544 let local_var_uri_str = format!("{}/event/{event_key}/teams/simple", local_var_configuration.base_path, event_key=crate::apis::urlencode(event_key));
545 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
546
547 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
548 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
549 }
550 if let Some(local_var_param_value) = if_none_match {
551 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
552 }
553 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
554 let local_var_key = local_var_apikey.key.clone();
555 let local_var_value = match local_var_apikey.prefix {
556 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
557 None => local_var_key,
558 };
559 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
560 };
561
562 let local_var_req = local_var_req_builder.build()?;
563 let local_var_resp = local_var_client.execute(local_var_req).await?;
564
565 let local_var_status = local_var_resp.status();
566 let local_var_content = local_var_resp.text().await?;
567
568 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
569 serde_json::from_str(&local_var_content).map_err(Error::from)
570 } else {
571 let local_var_entity: Option<GetEventTeamsSimpleError> = serde_json::from_str(&local_var_content).ok();
572 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
573 Err(Error::ResponseError(local_var_error))
574 }
575}
576
577pub async fn get_event_teams_statuses(configuration: &configuration::Configuration, event_key: &str, if_none_match: Option<&str>) -> Result<::std::collections::HashMap<String, crate::models::TeamEventStatus>, Error<GetEventTeamsStatusesError>> {
579 let local_var_configuration = configuration;
580
581 let local_var_client = &local_var_configuration.client;
582
583 let local_var_uri_str = format!("{}/event/{event_key}/teams/statuses", local_var_configuration.base_path, event_key=crate::apis::urlencode(event_key));
584 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
585
586 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
587 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
588 }
589 if let Some(local_var_param_value) = if_none_match {
590 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
591 }
592 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
593 let local_var_key = local_var_apikey.key.clone();
594 let local_var_value = match local_var_apikey.prefix {
595 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
596 None => local_var_key,
597 };
598 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
599 };
600
601 let local_var_req = local_var_req_builder.build()?;
602 let local_var_resp = local_var_client.execute(local_var_req).await?;
603
604 let local_var_status = local_var_resp.status();
605 let local_var_content = local_var_resp.text().await?;
606
607 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
608 serde_json::from_str(&local_var_content).map_err(Error::from)
609 } else {
610 let local_var_entity: Option<GetEventTeamsStatusesError> = serde_json::from_str(&local_var_content).ok();
611 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
612 Err(Error::ResponseError(local_var_error))
613 }
614}
615
616pub async fn get_events_by_year(configuration: &configuration::Configuration, year: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::Event>, Error<GetEventsByYearError>> {
618 let local_var_configuration = configuration;
619
620 let local_var_client = &local_var_configuration.client;
621
622 let local_var_uri_str = format!("{}/events/{year}", local_var_configuration.base_path, year=year);
623 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
624
625 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
626 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
627 }
628 if let Some(local_var_param_value) = if_none_match {
629 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
630 }
631 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
632 let local_var_key = local_var_apikey.key.clone();
633 let local_var_value = match local_var_apikey.prefix {
634 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
635 None => local_var_key,
636 };
637 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
638 };
639
640 let local_var_req = local_var_req_builder.build()?;
641 let local_var_resp = local_var_client.execute(local_var_req).await?;
642
643 let local_var_status = local_var_resp.status();
644 let local_var_content = local_var_resp.text().await?;
645
646 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
647 serde_json::from_str(&local_var_content).map_err(Error::from)
648 } else {
649 let local_var_entity: Option<GetEventsByYearError> = serde_json::from_str(&local_var_content).ok();
650 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
651 Err(Error::ResponseError(local_var_error))
652 }
653}
654
655pub async fn get_events_by_year_keys(configuration: &configuration::Configuration, year: i32, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetEventsByYearKeysError>> {
657 let local_var_configuration = configuration;
658
659 let local_var_client = &local_var_configuration.client;
660
661 let local_var_uri_str = format!("{}/events/{year}/keys", local_var_configuration.base_path, year=year);
662 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
663
664 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
665 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
666 }
667 if let Some(local_var_param_value) = if_none_match {
668 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
669 }
670 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
671 let local_var_key = local_var_apikey.key.clone();
672 let local_var_value = match local_var_apikey.prefix {
673 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
674 None => local_var_key,
675 };
676 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
677 };
678
679 let local_var_req = local_var_req_builder.build()?;
680 let local_var_resp = local_var_client.execute(local_var_req).await?;
681
682 let local_var_status = local_var_resp.status();
683 let local_var_content = local_var_resp.text().await?;
684
685 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
686 serde_json::from_str(&local_var_content).map_err(Error::from)
687 } else {
688 let local_var_entity: Option<GetEventsByYearKeysError> = serde_json::from_str(&local_var_content).ok();
689 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
690 Err(Error::ResponseError(local_var_error))
691 }
692}
693
694pub async fn get_events_by_year_simple(configuration: &configuration::Configuration, year: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::EventSimple>, Error<GetEventsByYearSimpleError>> {
696 let local_var_configuration = configuration;
697
698 let local_var_client = &local_var_configuration.client;
699
700 let local_var_uri_str = format!("{}/events/{year}/simple", local_var_configuration.base_path, year=year);
701 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
702
703 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
704 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
705 }
706 if let Some(local_var_param_value) = if_none_match {
707 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
708 }
709 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
710 let local_var_key = local_var_apikey.key.clone();
711 let local_var_value = match local_var_apikey.prefix {
712 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
713 None => local_var_key,
714 };
715 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
716 };
717
718 let local_var_req = local_var_req_builder.build()?;
719 let local_var_resp = local_var_client.execute(local_var_req).await?;
720
721 let local_var_status = local_var_resp.status();
722 let local_var_content = local_var_resp.text().await?;
723
724 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
725 serde_json::from_str(&local_var_content).map_err(Error::from)
726 } else {
727 let local_var_entity: Option<GetEventsByYearSimpleError> = serde_json::from_str(&local_var_content).ok();
728 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
729 Err(Error::ResponseError(local_var_error))
730 }
731}
732
733pub async fn get_team_events_statuses_by_year(configuration: &configuration::Configuration, team_key: &str, year: i32, if_none_match: Option<&str>) -> Result<::std::collections::HashMap<String, crate::models::TeamEventStatus>, Error<GetTeamEventsStatusesByYearError>> {
735 let local_var_configuration = configuration;
736
737 let local_var_client = &local_var_configuration.client;
738
739 let local_var_uri_str = format!("{}/team/{team_key}/events/{year}/statuses", local_var_configuration.base_path, team_key=crate::apis::urlencode(team_key), year=year);
740 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
741
742 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
743 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
744 }
745 if let Some(local_var_param_value) = if_none_match {
746 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
747 }
748 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
749 let local_var_key = local_var_apikey.key.clone();
750 let local_var_value = match local_var_apikey.prefix {
751 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
752 None => local_var_key,
753 };
754 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
755 };
756
757 let local_var_req = local_var_req_builder.build()?;
758 let local_var_resp = local_var_client.execute(local_var_req).await?;
759
760 let local_var_status = local_var_resp.status();
761 let local_var_content = local_var_resp.text().await?;
762
763 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
764 serde_json::from_str(&local_var_content).map_err(Error::from)
765 } else {
766 let local_var_entity: Option<GetTeamEventsStatusesByYearError> = serde_json::from_str(&local_var_content).ok();
767 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
768 Err(Error::ResponseError(local_var_error))
769 }
770}
771
772pub async fn get_teams(configuration: &configuration::Configuration, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::Team>, Error<GetTeamsError>> {
774 let local_var_configuration = configuration;
775
776 let local_var_client = &local_var_configuration.client;
777
778 let local_var_uri_str = format!("{}/teams/{page_num}", local_var_configuration.base_path, page_num=page_num);
779 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
780
781 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
782 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
783 }
784 if let Some(local_var_param_value) = if_none_match {
785 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
786 }
787 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
788 let local_var_key = local_var_apikey.key.clone();
789 let local_var_value = match local_var_apikey.prefix {
790 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
791 None => local_var_key,
792 };
793 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
794 };
795
796 let local_var_req = local_var_req_builder.build()?;
797 let local_var_resp = local_var_client.execute(local_var_req).await?;
798
799 let local_var_status = local_var_resp.status();
800 let local_var_content = local_var_resp.text().await?;
801
802 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
803 serde_json::from_str(&local_var_content).map_err(Error::from)
804 } else {
805 let local_var_entity: Option<GetTeamsError> = serde_json::from_str(&local_var_content).ok();
806 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
807 Err(Error::ResponseError(local_var_error))
808 }
809}
810
811pub async fn get_teams_by_year(configuration: &configuration::Configuration, year: i32, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::Team>, Error<GetTeamsByYearError>> {
813 let local_var_configuration = configuration;
814
815 let local_var_client = &local_var_configuration.client;
816
817 let local_var_uri_str = format!("{}/teams/{year}/{page_num}", local_var_configuration.base_path, year=year, page_num=page_num);
818 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
819
820 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
821 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
822 }
823 if let Some(local_var_param_value) = if_none_match {
824 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
825 }
826 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
827 let local_var_key = local_var_apikey.key.clone();
828 let local_var_value = match local_var_apikey.prefix {
829 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
830 None => local_var_key,
831 };
832 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
833 };
834
835 let local_var_req = local_var_req_builder.build()?;
836 let local_var_resp = local_var_client.execute(local_var_req).await?;
837
838 let local_var_status = local_var_resp.status();
839 let local_var_content = local_var_resp.text().await?;
840
841 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
842 serde_json::from_str(&local_var_content).map_err(Error::from)
843 } else {
844 let local_var_entity: Option<GetTeamsByYearError> = serde_json::from_str(&local_var_content).ok();
845 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
846 Err(Error::ResponseError(local_var_error))
847 }
848}
849
850pub async fn get_teams_by_year_keys(configuration: &configuration::Configuration, year: i32, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetTeamsByYearKeysError>> {
852 let local_var_configuration = configuration;
853
854 let local_var_client = &local_var_configuration.client;
855
856 let local_var_uri_str = format!("{}/teams/{year}/{page_num}/keys", local_var_configuration.base_path, year=year, page_num=page_num);
857 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
858
859 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
860 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
861 }
862 if let Some(local_var_param_value) = if_none_match {
863 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
864 }
865 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
866 let local_var_key = local_var_apikey.key.clone();
867 let local_var_value = match local_var_apikey.prefix {
868 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
869 None => local_var_key,
870 };
871 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
872 };
873
874 let local_var_req = local_var_req_builder.build()?;
875 let local_var_resp = local_var_client.execute(local_var_req).await?;
876
877 let local_var_status = local_var_resp.status();
878 let local_var_content = local_var_resp.text().await?;
879
880 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
881 serde_json::from_str(&local_var_content).map_err(Error::from)
882 } else {
883 let local_var_entity: Option<GetTeamsByYearKeysError> = serde_json::from_str(&local_var_content).ok();
884 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
885 Err(Error::ResponseError(local_var_error))
886 }
887}
888
889pub async fn get_teams_by_year_simple(configuration: &configuration::Configuration, year: i32, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::TeamSimple>, Error<GetTeamsByYearSimpleError>> {
891 let local_var_configuration = configuration;
892
893 let local_var_client = &local_var_configuration.client;
894
895 let local_var_uri_str = format!("{}/teams/{year}/{page_num}/simple", local_var_configuration.base_path, year=year, page_num=page_num);
896 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
897
898 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
899 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
900 }
901 if let Some(local_var_param_value) = if_none_match {
902 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
903 }
904 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
905 let local_var_key = local_var_apikey.key.clone();
906 let local_var_value = match local_var_apikey.prefix {
907 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
908 None => local_var_key,
909 };
910 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
911 };
912
913 let local_var_req = local_var_req_builder.build()?;
914 let local_var_resp = local_var_client.execute(local_var_req).await?;
915
916 let local_var_status = local_var_resp.status();
917 let local_var_content = local_var_resp.text().await?;
918
919 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
920 serde_json::from_str(&local_var_content).map_err(Error::from)
921 } else {
922 let local_var_entity: Option<GetTeamsByYearSimpleError> = serde_json::from_str(&local_var_content).ok();
923 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
924 Err(Error::ResponseError(local_var_error))
925 }
926}
927
928pub async fn get_teams_keys(configuration: &configuration::Configuration, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<String>, Error<GetTeamsKeysError>> {
930 let local_var_configuration = configuration;
931
932 let local_var_client = &local_var_configuration.client;
933
934 let local_var_uri_str = format!("{}/teams/{page_num}/keys", local_var_configuration.base_path, page_num=page_num);
935 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
936
937 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
938 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
939 }
940 if let Some(local_var_param_value) = if_none_match {
941 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
942 }
943 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
944 let local_var_key = local_var_apikey.key.clone();
945 let local_var_value = match local_var_apikey.prefix {
946 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
947 None => local_var_key,
948 };
949 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
950 };
951
952 let local_var_req = local_var_req_builder.build()?;
953 let local_var_resp = local_var_client.execute(local_var_req).await?;
954
955 let local_var_status = local_var_resp.status();
956 let local_var_content = local_var_resp.text().await?;
957
958 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
959 serde_json::from_str(&local_var_content).map_err(Error::from)
960 } else {
961 let local_var_entity: Option<GetTeamsKeysError> = serde_json::from_str(&local_var_content).ok();
962 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
963 Err(Error::ResponseError(local_var_error))
964 }
965}
966
967pub async fn get_teams_simple(configuration: &configuration::Configuration, page_num: i32, if_none_match: Option<&str>) -> Result<Vec<crate::models::TeamSimple>, Error<GetTeamsSimpleError>> {
969 let local_var_configuration = configuration;
970
971 let local_var_client = &local_var_configuration.client;
972
973 let local_var_uri_str = format!("{}/teams/{page_num}/simple", local_var_configuration.base_path, page_num=page_num);
974 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
975
976 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
977 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
978 }
979 if let Some(local_var_param_value) = if_none_match {
980 local_var_req_builder = local_var_req_builder.header("If-None-Match", local_var_param_value.to_string());
981 }
982 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
983 let local_var_key = local_var_apikey.key.clone();
984 let local_var_value = match local_var_apikey.prefix {
985 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
986 None => local_var_key,
987 };
988 local_var_req_builder = local_var_req_builder.header("X-TBA-Auth-Key", local_var_value);
989 };
990
991 let local_var_req = local_var_req_builder.build()?;
992 let local_var_resp = local_var_client.execute(local_var_req).await?;
993
994 let local_var_status = local_var_resp.status();
995 let local_var_content = local_var_resp.text().await?;
996
997 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
998 serde_json::from_str(&local_var_content).map_err(Error::from)
999 } else {
1000 let local_var_entity: Option<GetTeamsSimpleError> = serde_json::from_str(&local_var_content).ok();
1001 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1002 Err(Error::ResponseError(local_var_error))
1003 }
1004}
1005