warframe_client/apis/
warframe_items_api.rs

1/*
2 * WarframeStat.us API
3 *
4 * Simple API for data from the game Warframe. [Parser Docs](https://wfcd.github.io/warframe-worldstate-parser/) [Items Types](https://github.com/WFCD/warframe-items/blob/master/index.d.ts) 
5 *
6 * The version of the OpenAPI document: 2.0.8
7 * Contact: tobiah@protonmail.com
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`get_items_data`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum GetItemsDataError {
22    Status400(models::InlineObject),
23    Status500(models::InlineObject),
24    UnknownValue(serde_json::Value),
25}
26
27/// struct for typed errors of method [`get_mods_data`]
28#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum GetModsDataError {
31    Status400(models::InlineObject),
32    Status500(models::InlineObject),
33    UnknownValue(serde_json::Value),
34}
35
36/// struct for typed errors of method [`get_warframes_data`]
37#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum GetWarframesDataError {
40    Status400(models::InlineObject),
41    Status500(models::InlineObject),
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`get_weapons_data`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum GetWeaponsDataError {
49    Status400(models::InlineObject),
50    Status500(models::InlineObject),
51    UnknownValue(serde_json::Value),
52}
53
54/// struct for typed errors of method [`search_item_data`]
55#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum SearchItemDataError {
58    Status400(models::InlineObject),
59    Status500(models::InlineObject),
60    UnknownValue(serde_json::Value),
61}
62
63/// struct for typed errors of method [`search_items_data`]
64#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum SearchItemsDataError {
67    Status400(models::InlineObject),
68    Status500(models::InlineObject),
69    UnknownValue(serde_json::Value),
70}
71
72/// struct for typed errors of method [`search_mod_data`]
73#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum SearchModDataError {
76    Status400(models::InlineObject),
77    Status500(models::InlineObject),
78    UnknownValue(serde_json::Value),
79}
80
81/// struct for typed errors of method [`search_mods_data`]
82#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum SearchModsDataError {
85    Status400(models::InlineObject),
86    Status500(models::InlineObject),
87    UnknownValue(serde_json::Value),
88}
89
90/// struct for typed errors of method [`search_warframe_data`]
91#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum SearchWarframeDataError {
94    Status400(models::InlineObject),
95    Status500(models::InlineObject),
96    UnknownValue(serde_json::Value),
97}
98
99/// struct for typed errors of method [`search_warframes_data`]
100#[derive(Debug, Clone, Serialize, Deserialize)]
101#[serde(untagged)]
102pub enum SearchWarframesDataError {
103    Status400(models::InlineObject),
104    Status500(models::InlineObject),
105    UnknownValue(serde_json::Value),
106}
107
108/// struct for typed errors of method [`search_weapon_data`]
109#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum SearchWeaponDataError {
112    Status400(models::InlineObject),
113    Status500(models::InlineObject),
114    UnknownValue(serde_json::Value),
115}
116
117/// struct for typed errors of method [`search_weapons_data`]
118#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum SearchWeaponsDataError {
121    Status400(models::InlineObject),
122    Status500(models::InlineObject),
123    UnknownValue(serde_json::Value),
124}
125
126
127/// Item information.
128pub async fn get_items_data(configuration: &configuration::Configuration, language: models::Language, only: Option<&str>, remove: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::ItemsInner>, Error<GetItemsDataError>> {
129    // add a prefix to parameters to efficiently prevent name collisions
130    let p_query_language = language;
131    let p_query_only = only;
132    let p_query_remove = remove;
133    let p_header_accept_language = accept_language;
134
135    let uri_str = format!("{}/items", configuration.base_path);
136    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
137
138    if let Some(ref param_value) = p_query_only {
139        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
140    }
141    if let Some(ref param_value) = p_query_remove {
142        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
143    }
144    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
145    if let Some(ref user_agent) = configuration.user_agent {
146        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
147    }
148    if let Some(param_value) = p_header_accept_language {
149        req_builder = req_builder.header("Accept-Language", param_value.to_string());
150    }
151
152    let req = req_builder.build()?;
153    let resp = configuration.client.execute(req).await?;
154
155    let status = resp.status();
156    let content_type = resp
157        .headers()
158        .get("content-type")
159        .and_then(|v| v.to_str().ok())
160        .unwrap_or("application/octet-stream");
161    let content_type = super::ContentType::from(content_type);
162
163    if !status.is_client_error() && !status.is_server_error() {
164        let content = resp.text().await?;
165        match content_type {
166            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
167            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ItemsInner&gt;`"))),
168            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ItemsInner&gt;`")))),
169        }
170    } else {
171        let content = resp.text().await?;
172        let entity: Option<GetItemsDataError> = serde_json::from_str(&content).ok();
173        Err(Error::ResponseError(ResponseContent { status, content, entity }))
174    }
175}
176
177pub async fn get_mods_data(configuration: &configuration::Configuration, language: models::Language, only: Option<&str>, remove: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::Mod>, Error<GetModsDataError>> {
178    // add a prefix to parameters to efficiently prevent name collisions
179    let p_query_language = language;
180    let p_query_only = only;
181    let p_query_remove = remove;
182    let p_header_accept_language = accept_language;
183
184    let uri_str = format!("{}/mods", configuration.base_path);
185    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
186
187    if let Some(ref param_value) = p_query_only {
188        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
189    }
190    if let Some(ref param_value) = p_query_remove {
191        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
192    }
193    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
194    if let Some(ref user_agent) = configuration.user_agent {
195        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
196    }
197    if let Some(param_value) = p_header_accept_language {
198        req_builder = req_builder.header("Accept-Language", param_value.to_string());
199    }
200
201    let req = req_builder.build()?;
202    let resp = configuration.client.execute(req).await?;
203
204    let status = resp.status();
205    let content_type = resp
206        .headers()
207        .get("content-type")
208        .and_then(|v| v.to_str().ok())
209        .unwrap_or("application/octet-stream");
210    let content_type = super::ContentType::from(content_type);
211
212    if !status.is_client_error() && !status.is_server_error() {
213        let content = resp.text().await?;
214        match content_type {
215            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
216            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Mod&gt;`"))),
217            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Mod&gt;`")))),
218        }
219    } else {
220        let content = resp.text().await?;
221        let entity: Option<GetModsDataError> = serde_json::from_str(&content).ok();
222        Err(Error::ResponseError(ResponseContent { status, content, entity }))
223    }
224}
225
226/// Warframe stats and general information.
227pub async fn get_warframes_data(configuration: &configuration::Configuration, language: models::Language, only: Option<&str>, remove: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::Warframe>, Error<GetWarframesDataError>> {
228    // add a prefix to parameters to efficiently prevent name collisions
229    let p_query_language = language;
230    let p_query_only = only;
231    let p_query_remove = remove;
232    let p_header_accept_language = accept_language;
233
234    let uri_str = format!("{}/warframes", configuration.base_path);
235    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
236
237    if let Some(ref param_value) = p_query_only {
238        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
239    }
240    if let Some(ref param_value) = p_query_remove {
241        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
242    }
243    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
244    if let Some(ref user_agent) = configuration.user_agent {
245        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
246    }
247    if let Some(param_value) = p_header_accept_language {
248        req_builder = req_builder.header("Accept-Language", param_value.to_string());
249    }
250
251    let req = req_builder.build()?;
252    let resp = configuration.client.execute(req).await?;
253
254    let status = resp.status();
255    let content_type = resp
256        .headers()
257        .get("content-type")
258        .and_then(|v| v.to_str().ok())
259        .unwrap_or("application/octet-stream");
260    let content_type = super::ContentType::from(content_type);
261
262    if !status.is_client_error() && !status.is_server_error() {
263        let content = resp.text().await?;
264        match content_type {
265            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
266            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Warframe&gt;`"))),
267            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Warframe&gt;`")))),
268        }
269    } else {
270        let content = resp.text().await?;
271        let entity: Option<GetWarframesDataError> = serde_json::from_str(&content).ok();
272        Err(Error::ResponseError(ResponseContent { status, content, entity }))
273    }
274}
275
276/// Weapon statistics.
277pub async fn get_weapons_data(configuration: &configuration::Configuration, language: models::Language, only: Option<&str>, remove: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::WeaponsInner>, Error<GetWeaponsDataError>> {
278    // add a prefix to parameters to efficiently prevent name collisions
279    let p_query_language = language;
280    let p_query_only = only;
281    let p_query_remove = remove;
282    let p_header_accept_language = accept_language;
283
284    let uri_str = format!("{}/weapons", configuration.base_path);
285    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
286
287    if let Some(ref param_value) = p_query_only {
288        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
289    }
290    if let Some(ref param_value) = p_query_remove {
291        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
292    }
293    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
294    if let Some(ref user_agent) = configuration.user_agent {
295        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
296    }
297    if let Some(param_value) = p_header_accept_language {
298        req_builder = req_builder.header("Accept-Language", param_value.to_string());
299    }
300
301    let req = req_builder.build()?;
302    let resp = configuration.client.execute(req).await?;
303
304    let status = resp.status();
305    let content_type = resp
306        .headers()
307        .get("content-type")
308        .and_then(|v| v.to_str().ok())
309        .unwrap_or("application/octet-stream");
310    let content_type = super::ContentType::from(content_type);
311
312    if !status.is_client_error() && !status.is_server_error() {
313        let content = resp.text().await?;
314        match content_type {
315            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
316            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::WeaponsInner&gt;`"))),
317            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::WeaponsInner&gt;`")))),
318        }
319    } else {
320        let content = resp.text().await?;
321        let entity: Option<GetWeaponsDataError> = serde_json::from_str(&content).ok();
322        Err(Error::ResponseError(ResponseContent { status, content, entity }))
323    }
324}
325
326/// Item information.
327pub async fn search_item_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<models::Item, Error<SearchItemDataError>> {
328    // add a prefix to parameters to efficiently prevent name collisions
329    let p_path_query = query;
330    let p_query_language = language;
331    let p_query_only = only;
332    let p_query_remove = remove;
333    let p_query_by = by;
334    let p_header_accept_language = accept_language;
335
336    let uri_str = format!("{}/items/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
337    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
338
339    if let Some(ref param_value) = p_query_only {
340        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
341    }
342    if let Some(ref param_value) = p_query_remove {
343        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
344    }
345    if let Some(ref param_value) = p_query_by {
346        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
347    }
348    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
349    if let Some(ref user_agent) = configuration.user_agent {
350        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
351    }
352    if let Some(param_value) = p_header_accept_language {
353        req_builder = req_builder.header("Accept-Language", param_value.to_string());
354    }
355
356    let req = req_builder.build()?;
357    let resp = configuration.client.execute(req).await?;
358
359    let status = resp.status();
360    let content_type = resp
361        .headers()
362        .get("content-type")
363        .and_then(|v| v.to_str().ok())
364        .unwrap_or("application/octet-stream");
365    let content_type = super::ContentType::from(content_type);
366
367    if !status.is_client_error() && !status.is_server_error() {
368        let content = resp.text().await?;
369        match content_type {
370            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
371            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Item`"))),
372            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Item`")))),
373        }
374    } else {
375        let content = resp.text().await?;
376        let entity: Option<SearchItemDataError> = serde_json::from_str(&content).ok();
377        Err(Error::ResponseError(ResponseContent { status, content, entity }))
378    }
379}
380
381/// Item information, such as name, unique name, type, and image name.
382pub async fn search_items_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::ItemsInner>, Error<SearchItemsDataError>> {
383    // add a prefix to parameters to efficiently prevent name collisions
384    let p_path_query = query;
385    let p_query_language = language;
386    let p_query_only = only;
387    let p_query_remove = remove;
388    let p_query_by = by;
389    let p_header_accept_language = accept_language;
390
391    let uri_str = format!("{}/items/search/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
392    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
393
394    if let Some(ref param_value) = p_query_only {
395        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
396    }
397    if let Some(ref param_value) = p_query_remove {
398        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
399    }
400    if let Some(ref param_value) = p_query_by {
401        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
402    }
403    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
404    if let Some(ref user_agent) = configuration.user_agent {
405        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
406    }
407    if let Some(param_value) = p_header_accept_language {
408        req_builder = req_builder.header("Accept-Language", param_value.to_string());
409    }
410
411    let req = req_builder.build()?;
412    let resp = configuration.client.execute(req).await?;
413
414    let status = resp.status();
415    let content_type = resp
416        .headers()
417        .get("content-type")
418        .and_then(|v| v.to_str().ok())
419        .unwrap_or("application/octet-stream");
420    let content_type = super::ContentType::from(content_type);
421
422    if !status.is_client_error() && !status.is_server_error() {
423        let content = resp.text().await?;
424        match content_type {
425            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
426            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::ItemsInner&gt;`"))),
427            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::ItemsInner&gt;`")))),
428        }
429    } else {
430        let content = resp.text().await?;
431        let entity: Option<SearchItemsDataError> = serde_json::from_str(&content).ok();
432        Err(Error::ResponseError(ResponseContent { status, content, entity }))
433    }
434}
435
436/// Mod information.
437pub async fn search_mod_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<models::Mod, Error<SearchModDataError>> {
438    // add a prefix to parameters to efficiently prevent name collisions
439    let p_path_query = query;
440    let p_query_language = language;
441    let p_query_only = only;
442    let p_query_remove = remove;
443    let p_query_by = by;
444    let p_header_accept_language = accept_language;
445
446    let uri_str = format!("{}/mods/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
447    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
448
449    if let Some(ref param_value) = p_query_only {
450        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
451    }
452    if let Some(ref param_value) = p_query_remove {
453        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
454    }
455    if let Some(ref param_value) = p_query_by {
456        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
457    }
458    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
459    if let Some(ref user_agent) = configuration.user_agent {
460        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
461    }
462    if let Some(param_value) = p_header_accept_language {
463        req_builder = req_builder.header("Accept-Language", param_value.to_string());
464    }
465
466    let req = req_builder.build()?;
467    let resp = configuration.client.execute(req).await?;
468
469    let status = resp.status();
470    let content_type = resp
471        .headers()
472        .get("content-type")
473        .and_then(|v| v.to_str().ok())
474        .unwrap_or("application/octet-stream");
475    let content_type = super::ContentType::from(content_type);
476
477    if !status.is_client_error() && !status.is_server_error() {
478        let content = resp.text().await?;
479        match content_type {
480            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
481            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Mod`"))),
482            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Mod`")))),
483        }
484    } else {
485        let content = resp.text().await?;
486        let entity: Option<SearchModDataError> = serde_json::from_str(&content).ok();
487        Err(Error::ResponseError(ResponseContent { status, content, entity }))
488    }
489}
490
491/// Mod information, such as name, unique name, type, and image name.
492pub async fn search_mods_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::Mod>, Error<SearchModsDataError>> {
493    // add a prefix to parameters to efficiently prevent name collisions
494    let p_path_query = query;
495    let p_query_language = language;
496    let p_query_only = only;
497    let p_query_remove = remove;
498    let p_query_by = by;
499    let p_header_accept_language = accept_language;
500
501    let uri_str = format!("{}/mods/search/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
502    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
503
504    if let Some(ref param_value) = p_query_only {
505        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
506    }
507    if let Some(ref param_value) = p_query_remove {
508        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
509    }
510    if let Some(ref param_value) = p_query_by {
511        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
512    }
513    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
514    if let Some(ref user_agent) = configuration.user_agent {
515        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
516    }
517    if let Some(param_value) = p_header_accept_language {
518        req_builder = req_builder.header("Accept-Language", param_value.to_string());
519    }
520
521    let req = req_builder.build()?;
522    let resp = configuration.client.execute(req).await?;
523
524    let status = resp.status();
525    let content_type = resp
526        .headers()
527        .get("content-type")
528        .and_then(|v| v.to_str().ok())
529        .unwrap_or("application/octet-stream");
530    let content_type = super::ContentType::from(content_type);
531
532    if !status.is_client_error() && !status.is_server_error() {
533        let content = resp.text().await?;
534        match content_type {
535            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
536            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Mod&gt;`"))),
537            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Mod&gt;`")))),
538        }
539    } else {
540        let content = resp.text().await?;
541        let entity: Option<SearchModsDataError> = serde_json::from_str(&content).ok();
542        Err(Error::ResponseError(ResponseContent { status, content, entity }))
543    }
544}
545
546/// Mod information.
547pub async fn search_warframe_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<models::Warframe, Error<SearchWarframeDataError>> {
548    // add a prefix to parameters to efficiently prevent name collisions
549    let p_path_query = query;
550    let p_query_language = language;
551    let p_query_only = only;
552    let p_query_remove = remove;
553    let p_query_by = by;
554    let p_header_accept_language = accept_language;
555
556    let uri_str = format!("{}/warframes/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
557    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
558
559    if let Some(ref param_value) = p_query_only {
560        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
561    }
562    if let Some(ref param_value) = p_query_remove {
563        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
564    }
565    if let Some(ref param_value) = p_query_by {
566        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
567    }
568    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
569    if let Some(ref user_agent) = configuration.user_agent {
570        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
571    }
572    if let Some(param_value) = p_header_accept_language {
573        req_builder = req_builder.header("Accept-Language", param_value.to_string());
574    }
575
576    let req = req_builder.build()?;
577    let resp = configuration.client.execute(req).await?;
578
579    let status = resp.status();
580    let content_type = resp
581        .headers()
582        .get("content-type")
583        .and_then(|v| v.to_str().ok())
584        .unwrap_or("application/octet-stream");
585    let content_type = super::ContentType::from(content_type);
586
587    if !status.is_client_error() && !status.is_server_error() {
588        let content = resp.text().await?;
589        match content_type {
590            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
591            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Warframe`"))),
592            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Warframe`")))),
593        }
594    } else {
595        let content = resp.text().await?;
596        let entity: Option<SearchWarframeDataError> = serde_json::from_str(&content).ok();
597        Err(Error::ResponseError(ResponseContent { status, content, entity }))
598    }
599}
600
601/// Warframe stats and general information.
602pub async fn search_warframes_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::Warframe>, Error<SearchWarframesDataError>> {
603    // add a prefix to parameters to efficiently prevent name collisions
604    let p_path_query = query;
605    let p_query_language = language;
606    let p_query_only = only;
607    let p_query_remove = remove;
608    let p_query_by = by;
609    let p_header_accept_language = accept_language;
610
611    let uri_str = format!("{}/warframes/search/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
612    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
613
614    if let Some(ref param_value) = p_query_only {
615        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
616    }
617    if let Some(ref param_value) = p_query_remove {
618        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
619    }
620    if let Some(ref param_value) = p_query_by {
621        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
622    }
623    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
624    if let Some(ref user_agent) = configuration.user_agent {
625        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
626    }
627    if let Some(param_value) = p_header_accept_language {
628        req_builder = req_builder.header("Accept-Language", param_value.to_string());
629    }
630
631    let req = req_builder.build()?;
632    let resp = configuration.client.execute(req).await?;
633
634    let status = resp.status();
635    let content_type = resp
636        .headers()
637        .get("content-type")
638        .and_then(|v| v.to_str().ok())
639        .unwrap_or("application/octet-stream");
640    let content_type = super::ContentType::from(content_type);
641
642    if !status.is_client_error() && !status.is_server_error() {
643        let content = resp.text().await?;
644        match content_type {
645            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
646            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Warframe&gt;`"))),
647            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::Warframe&gt;`")))),
648        }
649    } else {
650        let content = resp.text().await?;
651        let entity: Option<SearchWarframesDataError> = serde_json::from_str(&content).ok();
652        Err(Error::ResponseError(ResponseContent { status, content, entity }))
653    }
654}
655
656/// Mod information.
657pub async fn search_weapon_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<models::Weapon, Error<SearchWeaponDataError>> {
658    // add a prefix to parameters to efficiently prevent name collisions
659    let p_path_query = query;
660    let p_query_language = language;
661    let p_query_only = only;
662    let p_query_remove = remove;
663    let p_query_by = by;
664    let p_header_accept_language = accept_language;
665
666    let uri_str = format!("{}/weapons/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
667    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
668
669    if let Some(ref param_value) = p_query_only {
670        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
671    }
672    if let Some(ref param_value) = p_query_remove {
673        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
674    }
675    if let Some(ref param_value) = p_query_by {
676        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
677    }
678    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
679    if let Some(ref user_agent) = configuration.user_agent {
680        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
681    }
682    if let Some(param_value) = p_header_accept_language {
683        req_builder = req_builder.header("Accept-Language", param_value.to_string());
684    }
685
686    let req = req_builder.build()?;
687    let resp = configuration.client.execute(req).await?;
688
689    let status = resp.status();
690    let content_type = resp
691        .headers()
692        .get("content-type")
693        .and_then(|v| v.to_str().ok())
694        .unwrap_or("application/octet-stream");
695    let content_type = super::ContentType::from(content_type);
696
697    if !status.is_client_error() && !status.is_server_error() {
698        let content = resp.text().await?;
699        match content_type {
700            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
701            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Weapon`"))),
702            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Weapon`")))),
703        }
704    } else {
705        let content = resp.text().await?;
706        let entity: Option<SearchWeaponDataError> = serde_json::from_str(&content).ok();
707        Err(Error::ResponseError(ResponseContent { status, content, entity }))
708    }
709}
710
711/// Weapon statistics.
712pub async fn search_weapons_data(configuration: &configuration::Configuration, query: &str, language: models::Language, only: Option<&str>, remove: Option<&str>, by: Option<&str>, accept_language: Option<models::Language>) -> Result<Vec<models::WeaponsInner>, Error<SearchWeaponsDataError>> {
713    // add a prefix to parameters to efficiently prevent name collisions
714    let p_path_query = query;
715    let p_query_language = language;
716    let p_query_only = only;
717    let p_query_remove = remove;
718    let p_query_by = by;
719    let p_header_accept_language = accept_language;
720
721    let uri_str = format!("{}/weapons/search/{query}", configuration.base_path, query=crate::apis::urlencode(p_path_query));
722    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
723
724    if let Some(ref param_value) = p_query_only {
725        req_builder = req_builder.query(&[("only", &param_value.to_string())]);
726    }
727    if let Some(ref param_value) = p_query_remove {
728        req_builder = req_builder.query(&[("remove", &param_value.to_string())]);
729    }
730    if let Some(ref param_value) = p_query_by {
731        req_builder = req_builder.query(&[("by", &param_value.to_string())]);
732    }
733    req_builder = req_builder.query(&[("language", &p_query_language.to_string())]);
734    if let Some(ref user_agent) = configuration.user_agent {
735        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
736    }
737    if let Some(param_value) = p_header_accept_language {
738        req_builder = req_builder.header("Accept-Language", param_value.to_string());
739    }
740
741    let req = req_builder.build()?;
742    let resp = configuration.client.execute(req).await?;
743
744    let status = resp.status();
745    let content_type = resp
746        .headers()
747        .get("content-type")
748        .and_then(|v| v.to_str().ok())
749        .unwrap_or("application/octet-stream");
750    let content_type = super::ContentType::from(content_type);
751
752    if !status.is_client_error() && !status.is_server_error() {
753        let content = resp.text().await?;
754        match content_type {
755            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
756            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::WeaponsInner&gt;`"))),
757            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::WeaponsInner&gt;`")))),
758        }
759    } else {
760        let content = resp.text().await?;
761        let entity: Option<SearchWeaponsDataError> = serde_json::from_str(&content).ok();
762        Err(Error::ResponseError(ResponseContent { status, content, entity }))
763    }
764}
765
warframe_client/apis/warframe_items_api.rs

warframe_client/apis/
warframe_items_api.rs
