gitbundle_sdk/apis/
users_api.rs

1/*
2 * GitBundle API
3 *
4 * GitBundle API documentation.
5 *
6 * The version of the OpenAPI document: 3.4.1
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_all_feeds`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum GetAllFeedsError {
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_all_groups`]
32#[derive(Debug, Clone, Serialize, Deserialize)]
33#[serde(untagged)]
34pub enum GetAllGroupsError {
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_all_repos`]
46#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum GetAllReposError {
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_all_users`]
60#[derive(Debug, Clone, Serialize, Deserialize)]
61#[serde(untagged)]
62pub enum GetAllUsersError {
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_profile_groups`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum GetProfileGroupsError {
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_profile_repos`]
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(untagged)]
90pub enum GetProfileReposError {
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_feeds`]
102#[derive(Debug, Clone, Serialize, Deserialize)]
103#[serde(untagged)]
104pub enum GetUsersFeedsError {
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_has_perm`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum GetUsersHasPermError {
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
129/// struct for typed errors of method [`get_users_heatmap`]
130#[derive(Debug, Clone, Serialize, Deserialize)]
131#[serde(untagged)]
132pub enum GetUsersHeatmapError {
133    Status400(models::JsonErrorResponseNull),
134    Status401(models::JsonErrorResponseNull),
135    Status403(models::JsonErrorResponseNull),
136    Status404(models::JsonErrorResponseNull),
137    Status409(models::JsonErrorResponseNull),
138    Status429(models::JsonErrorResponseNull),
139    Status500(models::JsonErrorResponseNull),
140    UnknownValue(serde_json::Value),
141}
142
143/// struct for typed errors of method [`get_users_stars`]
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(untagged)]
146pub enum GetUsersStarsError {
147    Status400(models::JsonErrorResponseNull),
148    Status401(models::JsonErrorResponseNull),
149    Status403(models::JsonErrorResponseNull),
150    Status404(models::JsonErrorResponseNull),
151    Status409(models::JsonErrorResponseNull),
152    Status429(models::JsonErrorResponseNull),
153    Status500(models::JsonErrorResponseNull),
154    UnknownValue(serde_json::Value),
155}
156
157/// struct for typed errors of method [`get_users_user`]
158#[derive(Debug, Clone, Serialize, Deserialize)]
159#[serde(untagged)]
160pub enum GetUsersUserError {
161    Status400(models::JsonErrorResponseNull),
162    Status401(models::JsonErrorResponseNull),
163    Status403(models::JsonErrorResponseNull),
164    Status404(models::JsonErrorResponseNull),
165    Status409(models::JsonErrorResponseNull),
166    Status429(models::JsonErrorResponseNull),
167    Status500(models::JsonErrorResponseNull),
168    UnknownValue(serde_json::Value),
169}
170
171pub async fn get_all_feeds(
172    configuration: &configuration::Configuration,
173    page: Option<i64>,
174    size: Option<i64>,
175    order: Option<models::OrderOption>,
176    r#type: Option<models::FeedType>,
177    before: Option<i64>,
178    after: Option<i64>,
179) -> Result<Vec<models::FeedRelations>, Error<GetAllFeedsError>> {
180    // add a prefix to parameters to efficiently prevent name collisions
181    let p_query_page = page;
182    let p_query_size = size;
183    let p_query_order = order;
184    let p_query_type = r#type;
185    let p_query_before = before;
186    let p_query_after = after;
187
188    let uri_str = format!("{}/users/feeds", configuration.base_path);
189    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
190
191    if let Some(ref param_value) = p_query_page {
192        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
193    }
194    if let Some(ref param_value) = p_query_size {
195        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
196    }
197    if let Some(ref param_value) = p_query_order {
198        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
199    }
200    if let Some(ref param_value) = p_query_type {
201        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
202    }
203    if let Some(ref param_value) = p_query_before {
204        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
205    }
206    if let Some(ref param_value) = p_query_after {
207        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
208    }
209    if let Some(ref user_agent) = configuration.user_agent {
210        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
211    }
212
213    let req = req_builder.build()?;
214    let resp = configuration.client.execute(req).await?;
215
216    let status = resp.status();
217    let content_type = resp
218        .headers()
219        .get("content-type")
220        .and_then(|v| v.to_str().ok())
221        .unwrap_or("application/octet-stream");
222    let content_type = super::ContentType::from(content_type);
223
224    if !status.is_client_error() && !status.is_server_error() {
225        let content = resp.text().await?;
226        match content_type {
227            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
228            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;`"))),
229            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;`")))),
230        }
231    } else {
232        let content = resp.text().await?;
233        let entity: Option<GetAllFeedsError> = serde_json::from_str(&content).ok();
234        Err(Error::ResponseError(ResponseContent {
235            status,
236            content,
237            entity,
238        }))
239    }
240}
241
242pub async fn get_all_groups(
243    configuration: &configuration::Configuration,
244    page: Option<i64>,
245    size: Option<i64>,
246    query: Option<&str>,
247    sort: Option<models::GroupSort>,
248    order: Option<models::OrderOption>,
249) -> Result<Vec<models::GroupModel>, Error<GetAllGroupsError>> {
250    // add a prefix to parameters to efficiently prevent name collisions
251    let p_query_page = page;
252    let p_query_size = size;
253    let p_query_query = query;
254    let p_query_sort = sort;
255    let p_query_order = order;
256
257    let uri_str = format!("{}/users/groups", configuration.base_path);
258    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
259
260    if let Some(ref param_value) = p_query_page {
261        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
262    }
263    if let Some(ref param_value) = p_query_size {
264        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
265    }
266    if let Some(ref param_value) = p_query_query {
267        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
268    }
269    if let Some(ref param_value) = p_query_sort {
270        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
271    }
272    if let Some(ref param_value) = p_query_order {
273        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
274    }
275    if let Some(ref user_agent) = configuration.user_agent {
276        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
277    }
278
279    let req = req_builder.build()?;
280    let resp = configuration.client.execute(req).await?;
281
282    let status = resp.status();
283    let content_type = resp
284        .headers()
285        .get("content-type")
286        .and_then(|v| v.to_str().ok())
287        .unwrap_or("application/octet-stream");
288    let content_type = super::ContentType::from(content_type);
289
290    if !status.is_client_error() && !status.is_server_error() {
291        let content = resp.text().await?;
292        match content_type {
293            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
294            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;`"))),
295            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;`")))),
296        }
297    } else {
298        let content = resp.text().await?;
299        let entity: Option<GetAllGroupsError> = serde_json::from_str(&content).ok();
300        Err(Error::ResponseError(ResponseContent {
301            status,
302            content,
303            entity,
304        }))
305    }
306}
307
308pub async fn get_all_repos(
309    configuration: &configuration::Configuration,
310    page: Option<i64>,
311    size: Option<i64>,
312    query: Option<&str>,
313    sort: Option<models::RepoSort>,
314    order: Option<models::OrderOption>,
315) -> Result<Vec<models::RepoParent>, Error<GetAllReposError>> {
316    // add a prefix to parameters to efficiently prevent name collisions
317    let p_query_page = page;
318    let p_query_size = size;
319    let p_query_query = query;
320    let p_query_sort = sort;
321    let p_query_order = order;
322
323    let uri_str = format!("{}/users/repos", configuration.base_path);
324    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
325
326    if let Some(ref param_value) = p_query_page {
327        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
328    }
329    if let Some(ref param_value) = p_query_size {
330        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
331    }
332    if let Some(ref param_value) = p_query_query {
333        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
334    }
335    if let Some(ref param_value) = p_query_sort {
336        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
337    }
338    if let Some(ref param_value) = p_query_order {
339        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
340    }
341    if let Some(ref user_agent) = configuration.user_agent {
342        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
343    }
344
345    let req = req_builder.build()?;
346    let resp = configuration.client.execute(req).await?;
347
348    let status = resp.status();
349    let content_type = resp
350        .headers()
351        .get("content-type")
352        .and_then(|v| v.to_str().ok())
353        .unwrap_or("application/octet-stream");
354    let content_type = super::ContentType::from(content_type);
355
356    if !status.is_client_error() && !status.is_server_error() {
357        let content = resp.text().await?;
358        match content_type {
359            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
360            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;`"))),
361            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;`")))),
362        }
363    } else {
364        let content = resp.text().await?;
365        let entity: Option<GetAllReposError> = serde_json::from_str(&content).ok();
366        Err(Error::ResponseError(ResponseContent {
367            status,
368            content,
369            entity,
370        }))
371    }
372}
373
374pub async fn get_all_users(
375    configuration: &configuration::Configuration,
376    page: Option<i64>,
377    size: Option<i64>,
378    query: Option<&str>,
379    types: Option<Vec<models::UserType>>,
380    sort: Option<models::UserSort>,
381    order: Option<models::OrderOption>,
382    admin: Option<bool>,
383) -> Result<Vec<models::UserModel>, Error<GetAllUsersError>> {
384    // add a prefix to parameters to efficiently prevent name collisions
385    let p_query_page = page;
386    let p_query_size = size;
387    let p_query_query = query;
388    let p_query_types = types;
389    let p_query_sort = sort;
390    let p_query_order = order;
391    let p_query_admin = admin;
392
393    let uri_str = format!("{}/users", configuration.base_path);
394    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
395
396    if let Some(ref param_value) = p_query_page {
397        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
398    }
399    if let Some(ref param_value) = p_query_size {
400        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
401    }
402    if let Some(ref param_value) = p_query_query {
403        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
404    }
405    if let Some(ref param_value) = p_query_types {
406        req_builder = match "multi" {
407            "multi" => req_builder.query(
408                &param_value
409                    .iter()
410                    .map(|p| ("types".to_owned(), p.to_string()))
411                    .collect::<Vec<(std::string::String, std::string::String)>>(),
412            ),
413            _ => req_builder.query(&[(
414                "types",
415                &param_value
416                    .iter()
417                    .map(|p| p.to_string())
418                    .collect::<Vec<String>>()
419                    .join(",")
420                    .to_string(),
421            )]),
422        };
423    }
424    if let Some(ref param_value) = p_query_sort {
425        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
426    }
427    if let Some(ref param_value) = p_query_order {
428        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
429    }
430    if let Some(ref param_value) = p_query_admin {
431        req_builder = req_builder.query(&[("admin", &param_value.to_string())]);
432    }
433    if let Some(ref apikey) = configuration.api_key {
434        let key = apikey.key.clone();
435        let value = match apikey.prefix {
436            Some(ref prefix) => format!("{} {}", prefix, key),
437            None => key,
438        };
439        req_builder = req_builder.query(&[("access_token", value)]);
440    }
441    if let Some(ref user_agent) = configuration.user_agent {
442        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
443    }
444    if let Some(ref auth_conf) = configuration.basic_auth {
445        req_builder = req_builder.basic_auth(auth_conf.0.to_owned(), auth_conf.1.to_owned());
446    };
447    if let Some(ref token) = configuration.bearer_access_token {
448        req_builder = req_builder.bearer_auth(token.to_owned());
449    };
450
451    let req = req_builder.build()?;
452    let resp = configuration.client.execute(req).await?;
453
454    let status = resp.status();
455    let content_type = resp
456        .headers()
457        .get("content-type")
458        .and_then(|v| v.to_str().ok())
459        .unwrap_or("application/octet-stream");
460    let content_type = super::ContentType::from(content_type);
461
462    if !status.is_client_error() && !status.is_server_error() {
463        let content = resp.text().await?;
464        match content_type {
465            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
466            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;`"))),
467            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;`")))),
468        }
469    } else {
470        let content = resp.text().await?;
471        let entity: Option<GetAllUsersError> = serde_json::from_str(&content).ok();
472        Err(Error::ResponseError(ResponseContent {
473            status,
474            content,
475            entity,
476        }))
477    }
478}
479
480pub async fn get_profile_groups(
481    configuration: &configuration::Configuration,
482    identifier: &str,
483    page: Option<i64>,
484    size: Option<i64>,
485    query: Option<&str>,
486    sort: Option<models::GroupSort>,
487    order: Option<models::OrderOption>,
488) -> Result<Vec<models::GroupModel>, Error<GetProfileGroupsError>> {
489    // add a prefix to parameters to efficiently prevent name collisions
490    let p_path_identifier = identifier;
491    let p_query_page = page;
492    let p_query_size = size;
493    let p_query_query = query;
494    let p_query_sort = sort;
495    let p_query_order = order;
496
497    let uri_str = format!(
498        "{}/users/{identifier}/groups",
499        configuration.base_path,
500        identifier = crate::apis::urlencode(p_path_identifier)
501    );
502    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
503
504    if let Some(ref param_value) = p_query_page {
505        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
506    }
507    if let Some(ref param_value) = p_query_size {
508        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
509    }
510    if let Some(ref param_value) = p_query_query {
511        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
512    }
513    if let Some(ref param_value) = p_query_sort {
514        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
515    }
516    if let Some(ref param_value) = p_query_order {
517        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
518    }
519    if let Some(ref user_agent) = configuration.user_agent {
520        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
521    }
522
523    let req = req_builder.build()?;
524    let resp = configuration.client.execute(req).await?;
525
526    let status = resp.status();
527    let content_type = resp
528        .headers()
529        .get("content-type")
530        .and_then(|v| v.to_str().ok())
531        .unwrap_or("application/octet-stream");
532    let content_type = super::ContentType::from(content_type);
533
534    if !status.is_client_error() && !status.is_server_error() {
535        let content = resp.text().await?;
536        match content_type {
537            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
538            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;`"))),
539            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;`")))),
540        }
541    } else {
542        let content = resp.text().await?;
543        let entity: Option<GetProfileGroupsError> = serde_json::from_str(&content).ok();
544        Err(Error::ResponseError(ResponseContent {
545            status,
546            content,
547            entity,
548        }))
549    }
550}
551
552pub async fn get_profile_repos(
553    configuration: &configuration::Configuration,
554    identifier: &str,
555    page: Option<i64>,
556    size: Option<i64>,
557    query: Option<&str>,
558    sort: Option<models::RepoSort>,
559    order: Option<models::OrderOption>,
560) -> Result<Vec<models::RepoParent>, Error<GetProfileReposError>> {
561    // add a prefix to parameters to efficiently prevent name collisions
562    let p_path_identifier = identifier;
563    let p_query_page = page;
564    let p_query_size = size;
565    let p_query_query = query;
566    let p_query_sort = sort;
567    let p_query_order = order;
568
569    let uri_str = format!(
570        "{}/users/{identifier}/repos",
571        configuration.base_path,
572        identifier = crate::apis::urlencode(p_path_identifier)
573    );
574    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
575
576    if let Some(ref param_value) = p_query_page {
577        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
578    }
579    if let Some(ref param_value) = p_query_size {
580        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
581    }
582    if let Some(ref param_value) = p_query_query {
583        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
584    }
585    if let Some(ref param_value) = p_query_sort {
586        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
587    }
588    if let Some(ref param_value) = p_query_order {
589        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
590    }
591    if let Some(ref user_agent) = configuration.user_agent {
592        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
593    }
594
595    let req = req_builder.build()?;
596    let resp = configuration.client.execute(req).await?;
597
598    let status = resp.status();
599    let content_type = resp
600        .headers()
601        .get("content-type")
602        .and_then(|v| v.to_str().ok())
603        .unwrap_or("application/octet-stream");
604    let content_type = super::ContentType::from(content_type);
605
606    if !status.is_client_error() && !status.is_server_error() {
607        let content = resp.text().await?;
608        match content_type {
609            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
610            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;`"))),
611            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;`")))),
612        }
613    } else {
614        let content = resp.text().await?;
615        let entity: Option<GetProfileReposError> = serde_json::from_str(&content).ok();
616        Err(Error::ResponseError(ResponseContent {
617            status,
618            content,
619            entity,
620        }))
621    }
622}
623
624pub async fn get_users_feeds(
625    configuration: &configuration::Configuration,
626    identifier: &str,
627    page: Option<i64>,
628    size: Option<i64>,
629    order: Option<models::OrderOption>,
630    r#type: Option<models::FeedType>,
631    before: Option<i64>,
632    after: Option<i64>,
633) -> Result<Vec<models::FeedRelations>, Error<GetUsersFeedsError>> {
634    // add a prefix to parameters to efficiently prevent name collisions
635    let p_path_identifier = identifier;
636    let p_query_page = page;
637    let p_query_size = size;
638    let p_query_order = order;
639    let p_query_type = r#type;
640    let p_query_before = before;
641    let p_query_after = after;
642
643    let uri_str = format!(
644        "{}/users/{identifier}/feeds",
645        configuration.base_path,
646        identifier = crate::apis::urlencode(p_path_identifier)
647    );
648    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
649
650    if let Some(ref param_value) = p_query_page {
651        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
652    }
653    if let Some(ref param_value) = p_query_size {
654        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
655    }
656    if let Some(ref param_value) = p_query_order {
657        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
658    }
659    if let Some(ref param_value) = p_query_type {
660        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
661    }
662    if let Some(ref param_value) = p_query_before {
663        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
664    }
665    if let Some(ref param_value) = p_query_after {
666        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
667    }
668    if let Some(ref user_agent) = configuration.user_agent {
669        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
670    }
671
672    let req = req_builder.build()?;
673    let resp = configuration.client.execute(req).await?;
674
675    let status = resp.status();
676    let content_type = resp
677        .headers()
678        .get("content-type")
679        .and_then(|v| v.to_str().ok())
680        .unwrap_or("application/octet-stream");
681    let content_type = super::ContentType::from(content_type);
682
683    if !status.is_client_error() && !status.is_server_error() {
684        let content = resp.text().await?;
685        match content_type {
686            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
687            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;`"))),
688            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;`")))),
689        }
690    } else {
691        let content = resp.text().await?;
692        let entity: Option<GetUsersFeedsError> = serde_json::from_str(&content).ok();
693        Err(Error::ResponseError(ResponseContent {
694            status,
695            content,
696            entity,
697        }))
698    }
699}
700
701pub async fn get_users_has_perm(
702    configuration: &configuration::Configuration,
703    identifier: &str,
704    repo_ref: &str,
705    perm: models::Permission,
706) -> Result<bool, Error<GetUsersHasPermError>> {
707    // add a prefix to parameters to efficiently prevent name collisions
708    let p_path_identifier = identifier;
709    let p_path_repo_ref = repo_ref;
710    let p_query_perm = perm;
711
712    let uri_str = format!(
713        "{}/users/{identifier}/{repo_ref}/+/has_perm",
714        configuration.base_path,
715        identifier = crate::apis::urlencode(p_path_identifier),
716        repo_ref = crate::apis::urlencode(p_path_repo_ref)
717    );
718    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
719
720    req_builder = req_builder.query(&[("perm", &p_query_perm.to_string())]);
721    if let Some(ref user_agent) = configuration.user_agent {
722        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
723    }
724
725    let req = req_builder.build()?;
726    let resp = configuration.client.execute(req).await?;
727
728    let status = resp.status();
729    let content_type = resp
730        .headers()
731        .get("content-type")
732        .and_then(|v| v.to_str().ok())
733        .unwrap_or("application/octet-stream");
734    let content_type = super::ContentType::from(content_type);
735
736    if !status.is_client_error() && !status.is_server_error() {
737        let content = resp.text().await?;
738        match content_type {
739            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
740            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))),
741            ContentType::Unsupported(unknown_type) => Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))),
742        }
743    } else {
744        let content = resp.text().await?;
745        let entity: Option<GetUsersHasPermError> = serde_json::from_str(&content).ok();
746        Err(Error::ResponseError(ResponseContent {
747            status,
748            content,
749            entity,
750        }))
751    }
752}
753
754pub async fn get_users_heatmap(
755    configuration: &configuration::Configuration,
756    identifier: &str,
757    before: Option<i64>,
758    after: Option<i64>,
759) -> Result<models::Heatmap, Error<GetUsersHeatmapError>> {
760    // add a prefix to parameters to efficiently prevent name collisions
761    let p_path_identifier = identifier;
762    let p_query_before = before;
763    let p_query_after = after;
764
765    let uri_str = format!(
766        "{}/users/{identifier}/heatmap",
767        configuration.base_path,
768        identifier = crate::apis::urlencode(p_path_identifier)
769    );
770    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
771
772    if let Some(ref param_value) = p_query_before {
773        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
774    }
775    if let Some(ref param_value) = p_query_after {
776        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
777    }
778    if let Some(ref user_agent) = configuration.user_agent {
779        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
780    }
781
782    let req = req_builder.build()?;
783    let resp = configuration.client.execute(req).await?;
784
785    let status = resp.status();
786    let content_type = resp
787        .headers()
788        .get("content-type")
789        .and_then(|v| v.to_str().ok())
790        .unwrap_or("application/octet-stream");
791    let content_type = super::ContentType::from(content_type);
792
793    if !status.is_client_error() && !status.is_server_error() {
794        let content = resp.text().await?;
795        match content_type {
796            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
797            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Heatmap`"))),
798            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`")))),
799        }
800    } else {
801        let content = resp.text().await?;
802        let entity: Option<GetUsersHeatmapError> = serde_json::from_str(&content).ok();
803        Err(Error::ResponseError(ResponseContent {
804            status,
805            content,
806            entity,
807        }))
808    }
809}
810
811pub async fn get_users_stars(
812    configuration: &configuration::Configuration,
813    identifier: &str,
814    page: Option<i64>,
815    size: Option<i64>,
816    query: Option<&str>,
817    sort: Option<models::RepoSort>,
818    order: Option<models::OrderOption>,
819) -> Result<Vec<models::RepoParent>, Error<GetUsersStarsError>> {
820    // add a prefix to parameters to efficiently prevent name collisions
821    let p_path_identifier = identifier;
822    let p_query_page = page;
823    let p_query_size = size;
824    let p_query_query = query;
825    let p_query_sort = sort;
826    let p_query_order = order;
827
828    let uri_str = format!(
829        "{}/users/{identifier}/stars",
830        configuration.base_path,
831        identifier = crate::apis::urlencode(p_path_identifier)
832    );
833    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
834
835    if let Some(ref param_value) = p_query_page {
836        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
837    }
838    if let Some(ref param_value) = p_query_size {
839        req_builder = req_builder.query(&[("size", &param_value.to_string())]);
840    }
841    if let Some(ref param_value) = p_query_query {
842        req_builder = req_builder.query(&[("query", &param_value.to_string())]);
843    }
844    if let Some(ref param_value) = p_query_sort {
845        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
846    }
847    if let Some(ref param_value) = p_query_order {
848        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
849    }
850    if let Some(ref user_agent) = configuration.user_agent {
851        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
852    }
853
854    let req = req_builder.build()?;
855    let resp = configuration.client.execute(req).await?;
856
857    let status = resp.status();
858    let content_type = resp
859        .headers()
860        .get("content-type")
861        .and_then(|v| v.to_str().ok())
862        .unwrap_or("application/octet-stream");
863    let content_type = super::ContentType::from(content_type);
864
865    if !status.is_client_error() && !status.is_server_error() {
866        let content = resp.text().await?;
867        match content_type {
868            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
869            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;`"))),
870            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;`")))),
871        }
872    } else {
873        let content = resp.text().await?;
874        let entity: Option<GetUsersStarsError> = serde_json::from_str(&content).ok();
875        Err(Error::ResponseError(ResponseContent {
876            status,
877            content,
878            entity,
879        }))
880    }
881}
882
883pub async fn get_users_user(
884    configuration: &configuration::Configuration,
885    identifier: &str,
886) -> Result<models::UserModel, Error<GetUsersUserError>> {
887    // add a prefix to parameters to efficiently prevent name collisions
888    let p_path_identifier = identifier;
889
890    let uri_str = format!(
891        "{}/users/{identifier}",
892        configuration.base_path,
893        identifier = crate::apis::urlencode(p_path_identifier)
894    );
895    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
896
897    if let Some(ref user_agent) = configuration.user_agent {
898        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
899    }
900
901    let req = req_builder.build()?;
902    let resp = configuration.client.execute(req).await?;
903
904    let status = resp.status();
905    let content_type = resp
906        .headers()
907        .get("content-type")
908        .and_then(|v| v.to_str().ok())
909        .unwrap_or("application/octet-stream");
910    let content_type = super::ContentType::from(content_type);
911
912    if !status.is_client_error() && !status.is_server_error() {
913        let content = resp.text().await?;
914        match content_type {
915            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
916            ContentType::Text => Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UserModel`"))),
917            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`")))),
918        }
919    } else {
920        let content = resp.text().await?;
921        let entity: Option<GetUsersUserError> = serde_json::from_str(&content).ok();
922        Err(Error::ResponseError(ResponseContent {
923            status,
924            content,
925            entity,
926        }))
927    }
928}
gitbundle_sdk/apis/users_api.rs

gitbundle_sdk/apis/
users_api.rs
