gitbundle_sdk/apis/
users_api.rs

1/*
2 * GitBundle API
3 *
4 * GitBundle API documentation.
5 *
6 * The version of the OpenAPI document: 3.0.0
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use reqwest;
12use serde::{de::Error as _, Deserialize, Serialize};
13
14use super::{configuration, ContentType, Error};
15use crate::{apis::ResponseContent, models};
16
17/// struct for typed errors of method [`get_profile_groups`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum GetProfileGroupsError {
21    Status400(models::JsonErrorResponseNull),
22    Status401(models::JsonErrorResponseNull),
23    Status403(models::JsonErrorResponseNull),
24    Status404(models::JsonErrorResponseNull),
25    Status409(models::JsonErrorResponseNull),
26    Status429(models::JsonErrorResponseNull),
27    Status500(models::JsonErrorResponseNull),
28    UnknownValue(serde_json::Value),
29}
30
31/// struct for typed errors of method [`get_profile_repos`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum GetProfileReposError {
35    Status400(models::JsonErrorResponseNull),
36    Status401(models::JsonErrorResponseNull),
37    Status403(models::JsonErrorResponseNull),
38    Status404(models::JsonErrorResponseNull),
39    Status409(models::JsonErrorResponseNull),
40    Status429(models::JsonErrorResponseNull),
41    Status500(models::JsonErrorResponseNull),
42    UnknownValue(serde_json::Value),
43}
44
45/// struct for typed errors of method [`get_users_feeds`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum GetUsersFeedsError {
49    Status400(models::JsonErrorResponseNull),
50    Status401(models::JsonErrorResponseNull),
51    Status403(models::JsonErrorResponseNull),
52    Status404(models::JsonErrorResponseNull),
53    Status409(models::JsonErrorResponseNull),
54    Status429(models::JsonErrorResponseNull),
55    Status500(models::JsonErrorResponseNull),
56    UnknownValue(serde_json::Value),
57}
58
59/// struct for typed errors of method [`get_users_has_perm`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum GetUsersHasPermError {
63    Status400(models::JsonErrorResponseNull),
64    Status401(models::JsonErrorResponseNull),
65    Status403(models::JsonErrorResponseNull),
66    Status404(models::JsonErrorResponseNull),
67    Status409(models::JsonErrorResponseNull),
68    Status429(models::JsonErrorResponseNull),
69    Status500(models::JsonErrorResponseNull),
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed errors of method [`get_users_heatmap`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum GetUsersHeatmapError {
77    Status400(models::JsonErrorResponseNull),
78    Status401(models::JsonErrorResponseNull),
79    Status403(models::JsonErrorResponseNull),
80    Status404(models::JsonErrorResponseNull),
81    Status409(models::JsonErrorResponseNull),
82    Status429(models::JsonErrorResponseNull),
83    Status500(models::JsonErrorResponseNull),
84    UnknownValue(serde_json::Value),
85}
86
87/// struct for typed errors of method [`get_users_stars`]
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum GetUsersStarsError {
91    Status400(models::JsonErrorResponseNull),
92    Status401(models::JsonErrorResponseNull),
93    Status403(models::JsonErrorResponseNull),
94    Status404(models::JsonErrorResponseNull),
95    Status409(models::JsonErrorResponseNull),
96    Status429(models::JsonErrorResponseNull),
97    Status500(models::JsonErrorResponseNull),
98    UnknownValue(serde_json::Value),
99}
100
101/// struct for typed errors of method [`get_users_user`]
102#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum GetUsersUserError {
105    Status400(models::JsonErrorResponseNull),
106    Status401(models::JsonErrorResponseNull),
107    Status403(models::JsonErrorResponseNull),
108    Status404(models::JsonErrorResponseNull),
109    Status409(models::JsonErrorResponseNull),
110    Status429(models::JsonErrorResponseNull),
111    Status500(models::JsonErrorResponseNull),
112    UnknownValue(serde_json::Value),
113}
114
115/// struct for typed errors of method [`get_users_users`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum GetUsersUsersError {
119    Status400(models::JsonErrorResponseNull),
120    Status401(models::JsonErrorResponseNull),
121    Status403(models::JsonErrorResponseNull),
122    Status404(models::JsonErrorResponseNull),
123    Status409(models::JsonErrorResponseNull),
124    Status429(models::JsonErrorResponseNull),
125    Status500(models::JsonErrorResponseNull),
126    UnknownValue(serde_json::Value),
127}
128
129pub async fn get_profile_groups(
130    configuration: &configuration::Configuration,
131    identifier: &str,
132    page: Option<i64>,
133    size: Option<i64>,
134    query: Option<&str>,
135    sort: Option<models::GroupSort>,
136    order: Option<models::OrderOption>,
137) -> Result<Vec<models::GroupModel>, Error<GetProfileGroupsError>> {
138    // add a prefix to parameters to efficiently prevent name collisions
139    let p_path_identifier = identifier;
140    let p_query_page = page;
141    let p_query_size = size;
142    let p_query_query = query;
143    let p_query_sort = sort;
144    let p_query_order = order;
145
146    let uri_str = format!(
147        "{}/users/{identifier}/groups",
148        configuration.base_path,
149        identifier = crate::apis::urlencode(p_path_identifier)
150    );
151    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
152
153    if let Some(ref param_value) = p_query_page {
154        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
155    }
156    if let Some(ref param_value) = p_query_size {
157        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
158    }
159    if let Some(ref param_value) = p_query_query {
160        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
161    }
162    if let Some(ref param_value) = p_query_sort {
163        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
164    }
165    if let Some(ref param_value) = p_query_order {
166        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
167    }
168    if let Some(ref user_agent) = configuration.user_agent {
169        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
170    }
171
172    let req = req_builder.build()?;
173    let resp = configuration.client.execute(req).await?;
174
175    let status = resp.status();
176    let content_type = resp
177        .headers()
178        .get("content-type")
179        .and_then(|v| v.to_str().ok())
180        .unwrap_or("application/octet-stream");
181    let content_type = super::ContentType::from(content_type);
182
183    if !status.is_client_error() && !status.is_server_error() {
184        let content = resp.text().await?;
185        match content_type {
186            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
187            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`"))),
188            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::GroupModel&gt;`")))),
189        }
190    } else {
191        let content = resp.text().await?;
192        let entity: Option<GetProfileGroupsError> = serde_json::from_str(&content).ok();
193        Err(Error::ResponseError(ResponseContent {
194            status,
195            content,
196            entity,
197        }))
198    }
199}
200
201pub async fn get_profile_repos(
202    configuration: &configuration::Configuration,
203    identifier: &str,
204    page: Option<i64>,
205    size: Option<i64>,
206    query: Option<&str>,
207    sort: Option<models::RepoSort>,
208    order: Option<models::OrderOption>,
209) -> Result<Vec<models::RepoParent>, Error<GetProfileReposError>> {
210    // add a prefix to parameters to efficiently prevent name collisions
211    let p_path_identifier = identifier;
212    let p_query_page = page;
213    let p_query_size = size;
214    let p_query_query = query;
215    let p_query_sort = sort;
216    let p_query_order = order;
217
218    let uri_str = format!(
219        "{}/users/{identifier}/repos",
220        configuration.base_path,
221        identifier = crate::apis::urlencode(p_path_identifier)
222    );
223    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
224
225    if let Some(ref param_value) = p_query_page {
226        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
227    }
228    if let Some(ref param_value) = p_query_size {
229        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
230    }
231    if let Some(ref param_value) = p_query_query {
232        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
233    }
234    if let Some(ref param_value) = p_query_sort {
235        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
236    }
237    if let Some(ref param_value) = p_query_order {
238        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
239    }
240    if let Some(ref user_agent) = configuration.user_agent {
241        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
242    }
243
244    let req = req_builder.build()?;
245    let resp = configuration.client.execute(req).await?;
246
247    let status = resp.status();
248    let content_type = resp
249        .headers()
250        .get("content-type")
251        .and_then(|v| v.to_str().ok())
252        .unwrap_or("application/octet-stream");
253    let content_type = super::ContentType::from(content_type);
254
255    if !status.is_client_error() && !status.is_server_error() {
256        let content = resp.text().await?;
257        match content_type {
258            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
259            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`"))),
260            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`")))),
261        }
262    } else {
263        let content = resp.text().await?;
264        let entity: Option<GetProfileReposError> = serde_json::from_str(&content).ok();
265        Err(Error::ResponseError(ResponseContent {
266            status,
267            content,
268            entity,
269        }))
270    }
271}
272
273pub async fn get_users_feeds(
274    configuration: &configuration::Configuration,
275    identifier: &str,
276    page: Option<i64>,
277    size: Option<i64>,
278    order: Option<models::OrderOption>,
279    r#type: Option<models::FeedType>,
280    before: Option<i64>,
281    after: Option<i64>,
282) -> Result<Vec<models::FeedRelations>, Error<GetUsersFeedsError>> {
283    // add a prefix to parameters to efficiently prevent name collisions
284    let p_path_identifier = identifier;
285    let p_query_page = page;
286    let p_query_size = size;
287    let p_query_order = order;
288    let p_query_type = r#type;
289    let p_query_before = before;
290    let p_query_after = after;
291
292    let uri_str = format!(
293        "{}/users/{identifier}/feeds",
294        configuration.base_path,
295        identifier = crate::apis::urlencode(p_path_identifier)
296    );
297    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
298
299    if let Some(ref param_value) = p_query_page {
300        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
301    }
302    if let Some(ref param_value) = p_query_size {
303        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
304    }
305    if let Some(ref param_value) = p_query_order {
306        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
307    }
308    if let Some(ref param_value) = p_query_type {
309        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
310    }
311    if let Some(ref param_value) = p_query_before {
312        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
313    }
314    if let Some(ref param_value) = p_query_after {
315        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
316    }
317    if let Some(ref user_agent) = configuration.user_agent {
318        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
319    }
320
321    let req = req_builder.build()?;
322    let resp = configuration.client.execute(req).await?;
323
324    let status = resp.status();
325    let content_type = resp
326        .headers()
327        .get("content-type")
328        .and_then(|v| v.to_str().ok())
329        .unwrap_or("application/octet-stream");
330    let content_type = super::ContentType::from(content_type);
331
332    if !status.is_client_error() && !status.is_server_error() {
333        let content = resp.text().await?;
334        match content_type {
335            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
336            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::FeedRelations&gt;`"))),
337            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::FeedRelations&gt;`")))),
338        }
339    } else {
340        let content = resp.text().await?;
341        let entity: Option<GetUsersFeedsError> = serde_json::from_str(&content).ok();
342        Err(Error::ResponseError(ResponseContent {
343            status,
344            content,
345            entity,
346        }))
347    }
348}
349
350pub async fn get_users_has_perm(
351    configuration: &configuration::Configuration,
352    identifier: &str,
353    repo_ref: &str,
354    perm: models::Permission,
355) -> Result<bool, Error<GetUsersHasPermError>> {
356    // add a prefix to parameters to efficiently prevent name collisions
357    let p_path_identifier = identifier;
358    let p_path_repo_ref = repo_ref;
359    let p_query_perm = perm;
360
361    let uri_str = format!(
362        "{}/users/{identifier}/{repo_ref}/+/has_perm",
363        configuration.base_path,
364        identifier = crate::apis::urlencode(p_path_identifier),
365        repo_ref = crate::apis::urlencode(p_path_repo_ref)
366    );
367    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
368
369    req_builder = req_builder.query(&[("perm", &p_query_perm.to_string())]);
370    if let Some(ref user_agent) = configuration.user_agent {
371        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
372    }
373
374    let req = req_builder.build()?;
375    let resp = configuration.client.execute(req).await?;
376
377    let status = resp.status();
378    let content_type = resp
379        .headers()
380        .get("content-type")
381        .and_then(|v| v.to_str().ok())
382        .unwrap_or("application/octet-stream");
383    let content_type = super::ContentType::from(content_type);
384
385    if !status.is_client_error() && !status.is_server_error() {
386        let content = resp.text().await?;
387        match content_type {
388            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
389            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))),
390            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))),
391        }
392    } else {
393        let content = resp.text().await?;
394        let entity: Option<GetUsersHasPermError> = serde_json::from_str(&content).ok();
395        Err(Error::ResponseError(ResponseContent {
396            status,
397            content,
398            entity,
399        }))
400    }
401}
402
403pub async fn get_users_heatmap(
404    configuration: &configuration::Configuration,
405    identifier: &str,
406    before: Option<i64>,
407    after: Option<i64>,
408) -> Result<models::Heatmap, Error<GetUsersHeatmapError>> {
409    // add a prefix to parameters to efficiently prevent name collisions
410    let p_path_identifier = identifier;
411    let p_query_before = before;
412    let p_query_after = after;
413
414    let uri_str = format!(
415        "{}/users/{identifier}/heatmap",
416        configuration.base_path,
417        identifier = crate::apis::urlencode(p_path_identifier)
418    );
419    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
420
421    if let Some(ref param_value) = p_query_before {
422        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
423    }
424    if let Some(ref param_value) = p_query_after {
425        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
426    }
427    if let Some(ref user_agent) = configuration.user_agent {
428        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
429    }
430
431    let req = req_builder.build()?;
432    let resp = configuration.client.execute(req).await?;
433
434    let status = resp.status();
435    let content_type = resp
436        .headers()
437        .get("content-type")
438        .and_then(|v| v.to_str().ok())
439        .unwrap_or("application/octet-stream");
440    let content_type = super::ContentType::from(content_type);
441
442    if !status.is_client_error() && !status.is_server_error() {
443        let content = resp.text().await?;
444        match content_type {
445            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
446            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Heatmap`"))),
447            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Heatmap`")))),
448        }
449    } else {
450        let content = resp.text().await?;
451        let entity: Option<GetUsersHeatmapError> = serde_json::from_str(&content).ok();
452        Err(Error::ResponseError(ResponseContent {
453            status,
454            content,
455            entity,
456        }))
457    }
458}
459
460pub async fn get_users_stars(
461    configuration: &configuration::Configuration,
462    identifier: &str,
463    page: Option<i64>,
464    size: Option<i64>,
465    query: Option<&str>,
466    sort: Option<models::RepoSort>,
467    order: Option<models::OrderOption>,
468) -> Result<Vec<models::RepoParent>, Error<GetUsersStarsError>> {
469    // add a prefix to parameters to efficiently prevent name collisions
470    let p_path_identifier = identifier;
471    let p_query_page = page;
472    let p_query_size = size;
473    let p_query_query = query;
474    let p_query_sort = sort;
475    let p_query_order = order;
476
477    let uri_str = format!(
478        "{}/users/{identifier}/stars",
479        configuration.base_path,
480        identifier = crate::apis::urlencode(p_path_identifier)
481    );
482    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
483
484    if let Some(ref param_value) = p_query_page {
485        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
486    }
487    if let Some(ref param_value) = p_query_size {
488        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
489    }
490    if let Some(ref param_value) = p_query_query {
491        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
492    }
493    if let Some(ref param_value) = p_query_sort {
494        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
495    }
496    if let Some(ref param_value) = p_query_order {
497        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
498    }
499    if let Some(ref user_agent) = configuration.user_agent {
500        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
501    }
502
503    let req = req_builder.build()?;
504    let resp = configuration.client.execute(req).await?;
505
506    let status = resp.status();
507    let content_type = resp
508        .headers()
509        .get("content-type")
510        .and_then(|v| v.to_str().ok())
511        .unwrap_or("application/octet-stream");
512    let content_type = super::ContentType::from(content_type);
513
514    if !status.is_client_error() && !status.is_server_error() {
515        let content = resp.text().await?;
516        match content_type {
517            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
518            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`"))),
519            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::RepoParent&gt;`")))),
520        }
521    } else {
522        let content = resp.text().await?;
523        let entity: Option<GetUsersStarsError> = serde_json::from_str(&content).ok();
524        Err(Error::ResponseError(ResponseContent {
525            status,
526            content,
527            entity,
528        }))
529    }
530}
531
532pub async fn get_users_user(
533    configuration: &configuration::Configuration,
534    identifier: &str,
535) -> Result<models::UserModel, Error<GetUsersUserError>> {
536    // add a prefix to parameters to efficiently prevent name collisions
537    let p_path_identifier = identifier;
538
539    let uri_str = format!(
540        "{}/users/{identifier}",
541        configuration.base_path,
542        identifier = crate::apis::urlencode(p_path_identifier)
543    );
544    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
545
546    if let Some(ref user_agent) = configuration.user_agent {
547        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
548    }
549
550    let req = req_builder.build()?;
551    let resp = configuration.client.execute(req).await?;
552
553    let status = resp.status();
554    let content_type = resp
555        .headers()
556        .get("content-type")
557        .and_then(|v| v.to_str().ok())
558        .unwrap_or("application/octet-stream");
559    let content_type = super::ContentType::from(content_type);
560
561    if !status.is_client_error() && !status.is_server_error() {
562        let content = resp.text().await?;
563        match content_type {
564            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
565            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserModel`"))),
566            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UserModel`")))),
567        }
568    } else {
569        let content = resp.text().await?;
570        let entity: Option<GetUsersUserError> = serde_json::from_str(&content).ok();
571        Err(Error::ResponseError(ResponseContent {
572            status,
573            content,
574            entity,
575        }))
576    }
577}
578
579pub async fn get_users_users(
580    configuration: &configuration::Configuration,
581    page: Option<i64>,
582    size: Option<i64>,
583    query: Option<&str>,
584    types: Option<Vec<models::UserType>>,
585    sort: Option<models::UserSort>,
586    order: Option<models::OrderOption>,
587    admin: Option<bool>,
588) -> Result<Vec<models::UserModel>, Error<GetUsersUsersError>> {
589    // add a prefix to parameters to efficiently prevent name collisions
590    let p_query_page = page;
591    let p_query_size = size;
592    let p_query_query = query;
593    let p_query_types = types;
594    let p_query_sort = sort;
595    let p_query_order = order;
596    let p_query_admin = admin;
597
598    let uri_str = format!("{}/users", configuration.base_path);
599    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
600
601    if let Some(ref param_value) = p_query_page {
602        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
603    }
604    if let Some(ref param_value) = p_query_size {
605        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
606    }
607    if let Some(ref param_value) = p_query_query {
608        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
609    }
610    if let Some(ref param_value) = p_query_types {
611        req_builder = match "multi" {
612            "multi" => req_builder.query(
613                &param_value
614                    .iter()
615                    .map(|p| ("types".to_owned(), p.to_string()))
616                    .collect::<Vec<(std::string::String, std::string::String)>>(),
617            ),
618            _ => req_builder.query(&[(
619                "types",
620                &param_value
621                    .iter()
622                    .map(|p| p.to_string())
623                    .collect::<Vec<String>>()
624                    .join(",")
625                    .to_string(),
626            )]),
627        };
628    }
629    if let Some(ref param_value) = p_query_sort {
630        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
631    }
632    if let Some(ref param_value) = p_query_order {
633        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
634    }
635    if let Some(ref param_value) = p_query_admin {
636        req_builder = req_builder.query(&[("admin", &param_value.to_string())]);
637    }
638    if let Some(ref apikey) = configuration.api_key {
639        let key = apikey.key.clone();
640        let value = match apikey.prefix {
641            Some(ref prefix) => format!("{} {}", prefix, key),
642            None => key,
643        };
644        req_builder = req_builder.query(&[("access_token", value)]);
645    }
646    if let Some(ref user_agent) = configuration.user_agent {
647        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
648    }
649    if let Some(ref auth_conf) = configuration.basic_auth {
650        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
651    };
652    if let Some(ref token) = configuration.bearer_access_token {
653        req_builder = req_builder.bearer_auth(token.to_owned());
654    };
655
656    let req = req_builder.build()?;
657    let resp = configuration.client.execute(req).await?;
658
659    let status = resp.status();
660    let content_type = resp
661        .headers()
662        .get("content-type")
663        .and_then(|v| v.to_str().ok())
664        .unwrap_or("application/octet-stream");
665    let content_type = super::ContentType::from(content_type);
666
667    if !status.is_client_error() && !status.is_server_error() {
668        let content = resp.text().await?;
669        match content_type {
670            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
671            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`"))),
672            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::UserModel&gt;`")))),
673        }
674    } else {
675        let content = resp.text().await?;
676        let entity: Option<GetUsersUsersError> = serde_json::from_str(&content).ok();
677        Err(Error::ResponseError(ResponseContent {
678            status,
679            content,
680            entity,
681        }))
682    }
683}
gitbundle_sdk/apis/users_api.rs

gitbundle_sdk/apis/
users_api.rs
