artifacts/apis/
events_api.rs

1use super::{configuration, Error};
2use crate::{apis::ResponseContent, models};
3use reqwest::StatusCode;
4use serde::{Deserialize, Serialize};
5
6/// struct for passing parameters to the method [`get_all_active_events`]
7#[derive(Clone, Debug)]
8pub struct GetAllActiveEventsParams {
9    /// Page number
10    pub page: Option<u32>,
11    /// Page size
12    pub size: Option<u32>,
13}
14
15impl GetAllActiveEventsParams {
16    pub fn new(page: Option<u32>, size: Option<u32>) -> Self {
17        Self { page, size }
18    }
19}
20
21/// struct for passing parameters to the method [`get_all_events`]
22#[derive(Clone, Debug)]
23pub struct GetAllEventsParams {
24    /// Type of event.
25    pub r#type: Option<models::MapContentType>,
26    /// Page number
27    pub page: Option<u32>,
28    /// Page size
29    pub size: Option<u32>,
30}
31
32impl GetAllEventsParams {
33    pub fn new(
34        r#type: Option<models::MapContentType>,
35        page: Option<u32>,
36        size: Option<u32>,
37    ) -> Self {
38        Self { r#type, page, size }
39    }
40}
41
42/// struct for typed errors of method [`get_all_active_events`]
43#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum GetAllActiveEventsError {}
46
47impl TryFrom<StatusCode> for GetAllActiveEventsError {
48    type Error = &'static str;
49    #[allow(clippy::match_single_binding)]
50    fn try_from(status: StatusCode) -> Result<Self, Self::Error> {
51        match status.as_u16() {
52            _ => Err("status code not in spec"),
53        }
54    }
55}
56
57/// struct for typed errors of method [`get_all_events`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum GetAllEventsError {}
61
62impl TryFrom<StatusCode> for GetAllEventsError {
63    type Error = &'static str;
64    #[allow(clippy::match_single_binding)]
65    fn try_from(status: StatusCode) -> Result<Self, Self::Error> {
66        match status.as_u16() {
67            _ => Err("status code not in spec"),
68        }
69    }
70}
71
72/// Fetch active events details.
73pub async fn get_all_active_events(
74    configuration: &configuration::Configuration,
75    params: GetAllActiveEventsParams,
76) -> Result<models::DataPageActiveEventSchema, Error<GetAllActiveEventsError>> {
77    let local_var_configuration = configuration;
78
79    // unbox the parameters
80    let page = params.page;
81    // unbox the parameters
82    let size = params.size;
83
84    let local_var_client = &local_var_configuration.client;
85
86    let local_var_uri_str = format!("{}/events/active", local_var_configuration.base_path);
87    let mut local_var_req_builder =
88        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
89
90    if let Some(ref local_var_str) = page {
91        local_var_req_builder =
92            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
93    }
94    if let Some(ref local_var_str) = size {
95        local_var_req_builder =
96            local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
97    }
98    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
99        local_var_req_builder =
100            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
101    }
102
103    let local_var_req = local_var_req_builder.build()?;
104    let local_var_resp = local_var_client.execute(local_var_req).await?;
105
106    let local_var_status = local_var_resp.status();
107    let local_var_content = local_var_resp.text().await?;
108
109    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
110        serde_json::from_str(&local_var_content).map_err(Error::from)
111    } else {
112        let local_var_entity: Option<GetAllActiveEventsError> = local_var_status.try_into().ok();
113        let local_var_error = ResponseContent {
114            status: local_var_status,
115            content: local_var_content,
116            entity: local_var_entity,
117        };
118        Err(Error::ResponseError(local_var_error))
119    }
120}
121
122/// Fetch events details.
123pub async fn get_all_events(
124    configuration: &configuration::Configuration,
125    params: GetAllEventsParams,
126) -> Result<models::DataPageEventSchema, Error<GetAllEventsError>> {
127    let local_var_configuration = configuration;
128
129    // unbox the parameters
130    let r#type = params.r#type;
131    // unbox the parameters
132    let page = params.page;
133    // unbox the parameters
134    let size = params.size;
135
136    let local_var_client = &local_var_configuration.client;
137
138    let local_var_uri_str = format!("{}/events", local_var_configuration.base_path);
139    let mut local_var_req_builder =
140        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
141
142    if let Some(ref local_var_str) = r#type {
143        local_var_req_builder =
144            local_var_req_builder.query(&[("type", &local_var_str.to_string())]);
145    }
146    if let Some(ref local_var_str) = page {
147        local_var_req_builder =
148            local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
149    }
150    if let Some(ref local_var_str) = size {
151        local_var_req_builder =
152            local_var_req_builder.query(&[("size", &local_var_str.to_string())]);
153    }
154    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
155        local_var_req_builder =
156            local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
157    }
158
159    let local_var_req = local_var_req_builder.build()?;
160    let local_var_resp = local_var_client.execute(local_var_req).await?;
161
162    let local_var_status = local_var_resp.status();
163    let local_var_content = local_var_resp.text().await?;
164
165    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
166        serde_json::from_str(&local_var_content).map_err(Error::from)
167    } else {
168        let local_var_entity: Option<GetAllEventsError> = local_var_status.try_into().ok();
169        let local_var_error = ResponseContent {
170            status: local_var_status,
171            content: local_var_content,
172            entity: local_var_entity,
173        };
174        Err(Error::ResponseError(local_var_error))
175    }
176}