1use reqwest;
12use serde::{Deserialize, Serialize};
13
14use super::{configuration, Error};
15use crate::{apis::ResponseContent, models};
16
17#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum FoldersGetError {
21 UnknownValue(serde_json::Value),
22}
23
24#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum FoldersIdDeleteError {
28 UnknownValue(serde_json::Value),
29}
30
31#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum FoldersIdDeletePostError {
35 UnknownValue(serde_json::Value),
36}
37
38#[derive(Debug, Clone, Serialize, Deserialize)]
40#[serde(untagged)]
41pub enum FoldersIdGetError {
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum FoldersIdPostError {
49 UnknownValue(serde_json::Value),
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(untagged)]
55pub enum FoldersIdPutError {
56 UnknownValue(serde_json::Value),
57}
58
59#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum FoldersPostError {
63 UnknownValue(serde_json::Value),
64}
65
66pub async fn folders_get(
67 configuration: &configuration::Configuration,
68) -> Result<models::FolderResponseModelListResponseModel, Error<FoldersGetError>> {
69 let local_var_configuration = configuration;
70
71 let local_var_client = &local_var_configuration.client;
72
73 let local_var_uri_str = format!("{}/folders", local_var_configuration.base_path);
74 let mut local_var_req_builder =
75 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
76
77 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
78 local_var_req_builder =
79 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
80 }
81 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
82 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
83 };
84
85 let local_var_req = local_var_req_builder.build()?;
86 let local_var_resp = local_var_client.execute(local_var_req).await?;
87
88 let local_var_status = local_var_resp.status();
89 let local_var_content = local_var_resp.text().await?;
90
91 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
92 serde_json::from_str(&local_var_content).map_err(Error::from)
93 } else {
94 let local_var_entity: Option<FoldersGetError> =
95 serde_json::from_str(&local_var_content).ok();
96 let local_var_error = ResponseContent {
97 status: local_var_status,
98 content: local_var_content,
99 entity: local_var_entity,
100 };
101 Err(Error::ResponseError(local_var_error))
102 }
103}
104
105pub async fn folders_id_delete(
106 configuration: &configuration::Configuration,
107 id: &str,
108) -> Result<(), Error<FoldersIdDeleteError>> {
109 let local_var_configuration = configuration;
110
111 let local_var_client = &local_var_configuration.client;
112
113 let local_var_uri_str = format!(
114 "{}/folders/{id}",
115 local_var_configuration.base_path,
116 id = crate::apis::urlencode(id)
117 );
118 let mut local_var_req_builder =
119 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
120
121 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
122 local_var_req_builder =
123 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
124 }
125 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
126 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
127 };
128
129 let local_var_req = local_var_req_builder.build()?;
130 let local_var_resp = local_var_client.execute(local_var_req).await?;
131
132 let local_var_status = local_var_resp.status();
133 let local_var_content = local_var_resp.text().await?;
134
135 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
136 Ok(())
137 } else {
138 let local_var_entity: Option<FoldersIdDeleteError> =
139 serde_json::from_str(&local_var_content).ok();
140 let local_var_error = ResponseContent {
141 status: local_var_status,
142 content: local_var_content,
143 entity: local_var_entity,
144 };
145 Err(Error::ResponseError(local_var_error))
146 }
147}
148
149pub async fn folders_id_delete_post(
150 configuration: &configuration::Configuration,
151 id: &str,
152) -> Result<(), Error<FoldersIdDeletePostError>> {
153 let local_var_configuration = configuration;
154
155 let local_var_client = &local_var_configuration.client;
156
157 let local_var_uri_str = format!(
158 "{}/folders/{id}/delete",
159 local_var_configuration.base_path,
160 id = crate::apis::urlencode(id)
161 );
162 let mut local_var_req_builder =
163 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
164
165 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
166 local_var_req_builder =
167 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
168 }
169 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
170 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
171 };
172
173 let local_var_req = local_var_req_builder.build()?;
174 let local_var_resp = local_var_client.execute(local_var_req).await?;
175
176 let local_var_status = local_var_resp.status();
177 let local_var_content = local_var_resp.text().await?;
178
179 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
180 Ok(())
181 } else {
182 let local_var_entity: Option<FoldersIdDeletePostError> =
183 serde_json::from_str(&local_var_content).ok();
184 let local_var_error = ResponseContent {
185 status: local_var_status,
186 content: local_var_content,
187 entity: local_var_entity,
188 };
189 Err(Error::ResponseError(local_var_error))
190 }
191}
192
193pub async fn folders_id_get(
194 configuration: &configuration::Configuration,
195 id: &str,
196) -> Result<models::FolderResponseModel, Error<FoldersIdGetError>> {
197 let local_var_configuration = configuration;
198
199 let local_var_client = &local_var_configuration.client;
200
201 let local_var_uri_str = format!(
202 "{}/folders/{id}",
203 local_var_configuration.base_path,
204 id = crate::apis::urlencode(id)
205 );
206 let mut local_var_req_builder =
207 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
208
209 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
210 local_var_req_builder =
211 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
212 }
213 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
214 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
215 };
216
217 let local_var_req = local_var_req_builder.build()?;
218 let local_var_resp = local_var_client.execute(local_var_req).await?;
219
220 let local_var_status = local_var_resp.status();
221 let local_var_content = local_var_resp.text().await?;
222
223 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
224 serde_json::from_str(&local_var_content).map_err(Error::from)
225 } else {
226 let local_var_entity: Option<FoldersIdGetError> =
227 serde_json::from_str(&local_var_content).ok();
228 let local_var_error = ResponseContent {
229 status: local_var_status,
230 content: local_var_content,
231 entity: local_var_entity,
232 };
233 Err(Error::ResponseError(local_var_error))
234 }
235}
236
237pub async fn folders_id_post(
238 configuration: &configuration::Configuration,
239 id: &str,
240 folder_request_model: Option<models::FolderRequestModel>,
241) -> Result<models::FolderResponseModel, Error<FoldersIdPostError>> {
242 let local_var_configuration = configuration;
243
244 let local_var_client = &local_var_configuration.client;
245
246 let local_var_uri_str = format!(
247 "{}/folders/{id}",
248 local_var_configuration.base_path,
249 id = crate::apis::urlencode(id)
250 );
251 let mut local_var_req_builder =
252 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
253
254 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
255 local_var_req_builder =
256 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
257 }
258 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
259 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
260 };
261 local_var_req_builder = local_var_req_builder.json(&folder_request_model);
262
263 let local_var_req = local_var_req_builder.build()?;
264 let local_var_resp = local_var_client.execute(local_var_req).await?;
265
266 let local_var_status = local_var_resp.status();
267 let local_var_content = local_var_resp.text().await?;
268
269 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
270 serde_json::from_str(&local_var_content).map_err(Error::from)
271 } else {
272 let local_var_entity: Option<FoldersIdPostError> =
273 serde_json::from_str(&local_var_content).ok();
274 let local_var_error = ResponseContent {
275 status: local_var_status,
276 content: local_var_content,
277 entity: local_var_entity,
278 };
279 Err(Error::ResponseError(local_var_error))
280 }
281}
282
283pub async fn folders_id_put(
284 configuration: &configuration::Configuration,
285 id: &str,
286 folder_request_model: Option<models::FolderRequestModel>,
287) -> Result<models::FolderResponseModel, Error<FoldersIdPutError>> {
288 let local_var_configuration = configuration;
289
290 let local_var_client = &local_var_configuration.client;
291
292 let local_var_uri_str = format!(
293 "{}/folders/{id}",
294 local_var_configuration.base_path,
295 id = crate::apis::urlencode(id)
296 );
297 let mut local_var_req_builder =
298 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
299
300 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
301 local_var_req_builder =
302 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
303 }
304 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
305 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
306 };
307 local_var_req_builder = local_var_req_builder.json(&folder_request_model);
308
309 let local_var_req = local_var_req_builder.build()?;
310 let local_var_resp = local_var_client.execute(local_var_req).await?;
311
312 let local_var_status = local_var_resp.status();
313 let local_var_content = local_var_resp.text().await?;
314
315 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
316 serde_json::from_str(&local_var_content).map_err(Error::from)
317 } else {
318 let local_var_entity: Option<FoldersIdPutError> =
319 serde_json::from_str(&local_var_content).ok();
320 let local_var_error = ResponseContent {
321 status: local_var_status,
322 content: local_var_content,
323 entity: local_var_entity,
324 };
325 Err(Error::ResponseError(local_var_error))
326 }
327}
328
329pub async fn folders_post(
330 configuration: &configuration::Configuration,
331 folder_request_model: Option<models::FolderRequestModel>,
332) -> Result<models::FolderResponseModel, Error<FoldersPostError>> {
333 let local_var_configuration = configuration;
334
335 let local_var_client = &local_var_configuration.client;
336
337 let local_var_uri_str = format!("{}/folders", local_var_configuration.base_path);
338 let mut local_var_req_builder =
339 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
340
341 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
342 local_var_req_builder =
343 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
344 }
345 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
346 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
347 };
348 local_var_req_builder = local_var_req_builder.json(&folder_request_model);
349
350 let local_var_req = local_var_req_builder.build()?;
351 let local_var_resp = local_var_client.execute(local_var_req).await?;
352
353 let local_var_status = local_var_resp.status();
354 let local_var_content = local_var_resp.text().await?;
355
356 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
357 serde_json::from_str(&local_var_content).map_err(Error::from)
358 } else {
359 let local_var_entity: Option<FoldersPostError> =
360 serde_json::from_str(&local_var_content).ok();
361 let local_var_error = ResponseContent {
362 status: local_var_status,
363 content: local_var_content,
364 entity: local_var_entity,
365 };
366 Err(Error::ResponseError(local_var_error))
367 }
368}