clientapi_pbs/apis/
access_users_api.rs

1/*
2 * Proxmox Backup Server API
3 *
4 * Generated from apidoc.js. NOT an official Proxmox specification. See https://pbs.proxmox.com/docs/api-viewer/ for the upstream documentation.
5 *
6 * The version of the OpenAPI document: 9.x
7 * 
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 [`access_users_create_token`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AccessUsersCreateTokenError {
22    Status400(models::PbsError),
23    Status401(models::PbsError),
24    Status403(models::PbsError),
25    Status404(models::PbsError),
26    Status500(models::PbsError),
27    Status501(models::PbsError),
28    Status503(models::PbsError),
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`access_users_create_users`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum AccessUsersCreateUsersError {
36    Status400(models::PbsError),
37    Status401(models::PbsError),
38    Status403(models::PbsError),
39    Status404(models::PbsError),
40    Status500(models::PbsError),
41    Status501(models::PbsError),
42    Status503(models::PbsError),
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`access_users_delete_token`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum AccessUsersDeleteTokenError {
50    Status400(models::PbsError),
51    Status401(models::PbsError),
52    Status403(models::PbsError),
53    Status404(models::PbsError),
54    Status500(models::PbsError),
55    Status501(models::PbsError),
56    Status503(models::PbsError),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`access_users_delete_users`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum AccessUsersDeleteUsersError {
64    Status400(models::PbsError),
65    Status401(models::PbsError),
66    Status403(models::PbsError),
67    Status404(models::PbsError),
68    Status500(models::PbsError),
69    Status501(models::PbsError),
70    Status503(models::PbsError),
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`access_users_get_access_users_by_userid`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum AccessUsersGetAccessUsersByUseridError {
78    Status400(models::PbsError),
79    Status401(models::PbsError),
80    Status403(models::PbsError),
81    Status404(models::PbsError),
82    Status500(models::PbsError),
83    Status501(models::PbsError),
84    Status503(models::PbsError),
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`access_users_get_access_users_by_userid_token_by_token_name`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum AccessUsersGetAccessUsersByUseridTokenByTokenNameError {
92    Status400(models::PbsError),
93    Status401(models::PbsError),
94    Status403(models::PbsError),
95    Status404(models::PbsError),
96    Status500(models::PbsError),
97    Status501(models::PbsError),
98    Status503(models::PbsError),
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`access_users_get_token`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum AccessUsersGetTokenError {
106    Status400(models::PbsError),
107    Status401(models::PbsError),
108    Status403(models::PbsError),
109    Status404(models::PbsError),
110    Status500(models::PbsError),
111    Status501(models::PbsError),
112    Status503(models::PbsError),
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`access_users_get_users`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum AccessUsersGetUsersError {
120    Status400(models::PbsError),
121    Status401(models::PbsError),
122    Status403(models::PbsError),
123    Status404(models::PbsError),
124    Status500(models::PbsError),
125    Status501(models::PbsError),
126    Status503(models::PbsError),
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`access_users_update_token`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum AccessUsersUpdateTokenError {
134    Status400(models::PbsError),
135    Status401(models::PbsError),
136    Status403(models::PbsError),
137    Status404(models::PbsError),
138    Status500(models::PbsError),
139    Status501(models::PbsError),
140    Status503(models::PbsError),
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`access_users_update_unlock_tfa`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum AccessUsersUpdateUnlockTfaError {
148    Status400(models::PbsError),
149    Status401(models::PbsError),
150    Status403(models::PbsError),
151    Status404(models::PbsError),
152    Status500(models::PbsError),
153    Status501(models::PbsError),
154    Status503(models::PbsError),
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`access_users_update_users`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum AccessUsersUpdateUsersError {
162    Status400(models::PbsError),
163    Status401(models::PbsError),
164    Status403(models::PbsError),
165    Status404(models::PbsError),
166    Status500(models::PbsError),
167    Status501(models::PbsError),
168    Status503(models::PbsError),
169    UnknownValue(serde_json::Value),
170}
171
172
173/// Generate a new API token with given metadata
174pub async fn access_users_create_token(configuration: &configuration::Configuration, token_name: &str, userid: &str, access_users_create_token_request: Option<models::AccessUsersCreateTokenRequest>) -> Result<models::AccessUsersCreateTokenResponse, Error<AccessUsersCreateTokenError>> {
175    // add a prefix to parameters to efficiently prevent name collisions
176    let p_path_token_name = token_name;
177    let p_path_userid = userid;
178    let p_body_access_users_create_token_request = access_users_create_token_request;
179
180    let uri_str = format!("{}/access/users/{userid}/token/{token_name}", configuration.base_path, token_name=crate::apis::urlencode(p_path_token_name), userid=crate::apis::urlencode(p_path_userid));
181    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
182
183    if let Some(ref user_agent) = configuration.user_agent {
184        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
185    }
186    if let Some(ref apikey) = configuration.api_key {
187        let key = apikey.key.clone();
188        let value = match apikey.prefix {
189            Some(ref prefix) => format!("{} {}", prefix, key),
190            None => key,
191        };
192        req_builder = req_builder.header("Authorization", value);
193    };
194    if let Some(ref apikey) = configuration.api_key {
195        let key = apikey.key.clone();
196        let value = match apikey.prefix {
197            Some(ref prefix) => format!("{} {}", prefix, key),
198            None => key,
199        };
200        req_builder = req_builder.header("CSRFPreventionToken", value);
201    };
202    req_builder = req_builder.json(&p_body_access_users_create_token_request);
203
204    let req = req_builder.build()?;
205    let resp = configuration.client.execute(req).await?;
206
207    let status = resp.status();
208    let content_type = resp
209        .headers()
210        .get("content-type")
211        .and_then(|v| v.to_str().ok())
212        .unwrap_or("application/octet-stream");
213    let content_type = super::ContentType::from(content_type);
214
215    if !status.is_client_error() && !status.is_server_error() {
216        let content = resp.text().await?;
217        match content_type {
218            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
219            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersCreateTokenResponse`"))),
220            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::AccessUsersCreateTokenResponse`")))),
221        }
222    } else {
223        let content = resp.text().await?;
224        let entity: Option<AccessUsersCreateTokenError> = serde_json::from_str(&content).ok();
225        Err(Error::ResponseError(ResponseContent { status, content, entity }))
226    }
227}
228
229/// Create new user.
230pub async fn access_users_create_users(configuration: &configuration::Configuration, access_users_create_users_request: models::AccessUsersCreateUsersRequest) -> Result<models::AccessUsersCreateUsersResponse, Error<AccessUsersCreateUsersError>> {
231    // add a prefix to parameters to efficiently prevent name collisions
232    let p_body_access_users_create_users_request = access_users_create_users_request;
233
234    let uri_str = format!("{}/access/users", configuration.base_path);
235    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
236
237    if let Some(ref user_agent) = configuration.user_agent {
238        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
239    }
240    if let Some(ref apikey) = configuration.api_key {
241        let key = apikey.key.clone();
242        let value = match apikey.prefix {
243            Some(ref prefix) => format!("{} {}", prefix, key),
244            None => key,
245        };
246        req_builder = req_builder.header("Authorization", value);
247    };
248    if let Some(ref apikey) = configuration.api_key {
249        let key = apikey.key.clone();
250        let value = match apikey.prefix {
251            Some(ref prefix) => format!("{} {}", prefix, key),
252            None => key,
253        };
254        req_builder = req_builder.header("CSRFPreventionToken", value);
255    };
256    req_builder = req_builder.json(&p_body_access_users_create_users_request);
257
258    let req = req_builder.build()?;
259    let resp = configuration.client.execute(req).await?;
260
261    let status = resp.status();
262    let content_type = resp
263        .headers()
264        .get("content-type")
265        .and_then(|v| v.to_str().ok())
266        .unwrap_or("application/octet-stream");
267    let content_type = super::ContentType::from(content_type);
268
269    if !status.is_client_error() && !status.is_server_error() {
270        let content = resp.text().await?;
271        match content_type {
272            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
273            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersCreateUsersResponse`"))),
274            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::AccessUsersCreateUsersResponse`")))),
275        }
276    } else {
277        let content = resp.text().await?;
278        let entity: Option<AccessUsersCreateUsersError> = serde_json::from_str(&content).ok();
279        Err(Error::ResponseError(ResponseContent { status, content, entity }))
280    }
281}
282
283/// Delete a user's API token
284pub async fn access_users_delete_token(configuration: &configuration::Configuration, token_name: &str, userid: &str, digest: Option<&str>) -> Result<models::AccessUsersDeleteTokenResponse, Error<AccessUsersDeleteTokenError>> {
285    // add a prefix to parameters to efficiently prevent name collisions
286    let p_path_token_name = token_name;
287    let p_path_userid = userid;
288    let p_query_digest = digest;
289
290    let uri_str = format!("{}/access/users/{userid}/token/{token_name}", configuration.base_path, token_name=crate::apis::urlencode(p_path_token_name), userid=crate::apis::urlencode(p_path_userid));
291    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
292
293    if let Some(ref param_value) = p_query_digest {
294        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
295    }
296    if let Some(ref user_agent) = configuration.user_agent {
297        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
298    }
299    if let Some(ref apikey) = configuration.api_key {
300        let key = apikey.key.clone();
301        let value = match apikey.prefix {
302            Some(ref prefix) => format!("{} {}", prefix, key),
303            None => key,
304        };
305        req_builder = req_builder.header("Authorization", value);
306    };
307    if let Some(ref apikey) = configuration.api_key {
308        let key = apikey.key.clone();
309        let value = match apikey.prefix {
310            Some(ref prefix) => format!("{} {}", prefix, key),
311            None => key,
312        };
313        req_builder = req_builder.header("CSRFPreventionToken", value);
314    };
315
316    let req = req_builder.build()?;
317    let resp = configuration.client.execute(req).await?;
318
319    let status = resp.status();
320    let content_type = resp
321        .headers()
322        .get("content-type")
323        .and_then(|v| v.to_str().ok())
324        .unwrap_or("application/octet-stream");
325    let content_type = super::ContentType::from(content_type);
326
327    if !status.is_client_error() && !status.is_server_error() {
328        let content = resp.text().await?;
329        match content_type {
330            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
331            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersDeleteTokenResponse`"))),
332            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::AccessUsersDeleteTokenResponse`")))),
333        }
334    } else {
335        let content = resp.text().await?;
336        let entity: Option<AccessUsersDeleteTokenError> = serde_json::from_str(&content).ok();
337        Err(Error::ResponseError(ResponseContent { status, content, entity }))
338    }
339}
340
341/// Remove a user from the configuration file.
342pub async fn access_users_delete_users(configuration: &configuration::Configuration, userid: &str, digest: Option<&str>) -> Result<models::AccessUsersDeleteUsersResponse, Error<AccessUsersDeleteUsersError>> {
343    // add a prefix to parameters to efficiently prevent name collisions
344    let p_path_userid = userid;
345    let p_query_digest = digest;
346
347    let uri_str = format!("{}/access/users/{userid}", configuration.base_path, userid=crate::apis::urlencode(p_path_userid));
348    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
349
350    if let Some(ref param_value) = p_query_digest {
351        req_builder = req_builder.query(&[("digest", &param_value.to_string())]);
352    }
353    if let Some(ref user_agent) = configuration.user_agent {
354        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
355    }
356    if let Some(ref apikey) = configuration.api_key {
357        let key = apikey.key.clone();
358        let value = match apikey.prefix {
359            Some(ref prefix) => format!("{} {}", prefix, key),
360            None => key,
361        };
362        req_builder = req_builder.header("Authorization", value);
363    };
364    if let Some(ref apikey) = configuration.api_key {
365        let key = apikey.key.clone();
366        let value = match apikey.prefix {
367            Some(ref prefix) => format!("{} {}", prefix, key),
368            None => key,
369        };
370        req_builder = req_builder.header("CSRFPreventionToken", value);
371    };
372
373    let req = req_builder.build()?;
374    let resp = configuration.client.execute(req).await?;
375
376    let status = resp.status();
377    let content_type = resp
378        .headers()
379        .get("content-type")
380        .and_then(|v| v.to_str().ok())
381        .unwrap_or("application/octet-stream");
382    let content_type = super::ContentType::from(content_type);
383
384    if !status.is_client_error() && !status.is_server_error() {
385        let content = resp.text().await?;
386        match content_type {
387            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
388            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersDeleteUsersResponse`"))),
389            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::AccessUsersDeleteUsersResponse`")))),
390        }
391    } else {
392        let content = resp.text().await?;
393        let entity: Option<AccessUsersDeleteUsersError> = serde_json::from_str(&content).ok();
394        Err(Error::ResponseError(ResponseContent { status, content, entity }))
395    }
396}
397
398/// Read user configuration data.
399pub async fn access_users_get_access_users_by_userid(configuration: &configuration::Configuration, userid: &str) -> Result<models::AccessUsersGetAccessUsersByUseridResponse, Error<AccessUsersGetAccessUsersByUseridError>> {
400    // add a prefix to parameters to efficiently prevent name collisions
401    let p_path_userid = userid;
402
403    let uri_str = format!("{}/access/users/{userid}", configuration.base_path, userid=crate::apis::urlencode(p_path_userid));
404    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
405
406    if let Some(ref user_agent) = configuration.user_agent {
407        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
408    }
409    if let Some(ref apikey) = configuration.api_key {
410        let key = apikey.key.clone();
411        let value = match apikey.prefix {
412            Some(ref prefix) => format!("{} {}", prefix, key),
413            None => key,
414        };
415        req_builder = req_builder.header("Authorization", value);
416    };
417    if let Some(ref apikey) = configuration.api_key {
418        let key = apikey.key.clone();
419        let value = match apikey.prefix {
420            Some(ref prefix) => format!("{} {}", prefix, key),
421            None => key,
422        };
423        req_builder = req_builder.header("CSRFPreventionToken", value);
424    };
425
426    let req = req_builder.build()?;
427    let resp = configuration.client.execute(req).await?;
428
429    let status = resp.status();
430    let content_type = resp
431        .headers()
432        .get("content-type")
433        .and_then(|v| v.to_str().ok())
434        .unwrap_or("application/octet-stream");
435    let content_type = super::ContentType::from(content_type);
436
437    if !status.is_client_error() && !status.is_server_error() {
438        let content = resp.text().await?;
439        match content_type {
440            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
441            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersGetAccessUsersByUseridResponse`"))),
442            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::AccessUsersGetAccessUsersByUseridResponse`")))),
443        }
444    } else {
445        let content = resp.text().await?;
446        let entity: Option<AccessUsersGetAccessUsersByUseridError> = serde_json::from_str(&content).ok();
447        Err(Error::ResponseError(ResponseContent { status, content, entity }))
448    }
449}
450
451/// Read user's API token metadata
452pub async fn access_users_get_access_users_by_userid_token_by_token_name(configuration: &configuration::Configuration, token_name: &str, userid: &str) -> Result<models::AccessUsersGetAccessUsersByUseridTokenByTokenNameResponse, Error<AccessUsersGetAccessUsersByUseridTokenByTokenNameError>> {
453    // add a prefix to parameters to efficiently prevent name collisions
454    let p_path_token_name = token_name;
455    let p_path_userid = userid;
456
457    let uri_str = format!("{}/access/users/{userid}/token/{token_name}", configuration.base_path, token_name=crate::apis::urlencode(p_path_token_name), userid=crate::apis::urlencode(p_path_userid));
458    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
459
460    if let Some(ref user_agent) = configuration.user_agent {
461        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
462    }
463    if let Some(ref apikey) = configuration.api_key {
464        let key = apikey.key.clone();
465        let value = match apikey.prefix {
466            Some(ref prefix) => format!("{} {}", prefix, key),
467            None => key,
468        };
469        req_builder = req_builder.header("Authorization", value);
470    };
471    if let Some(ref apikey) = configuration.api_key {
472        let key = apikey.key.clone();
473        let value = match apikey.prefix {
474            Some(ref prefix) => format!("{} {}", prefix, key),
475            None => key,
476        };
477        req_builder = req_builder.header("CSRFPreventionToken", value);
478    };
479
480    let req = req_builder.build()?;
481    let resp = configuration.client.execute(req).await?;
482
483    let status = resp.status();
484    let content_type = resp
485        .headers()
486        .get("content-type")
487        .and_then(|v| v.to_str().ok())
488        .unwrap_or("application/octet-stream");
489    let content_type = super::ContentType::from(content_type);
490
491    if !status.is_client_error() && !status.is_server_error() {
492        let content = resp.text().await?;
493        match content_type {
494            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
495            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersGetAccessUsersByUseridTokenByTokenNameResponse`"))),
496            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::AccessUsersGetAccessUsersByUseridTokenByTokenNameResponse`")))),
497        }
498    } else {
499        let content = resp.text().await?;
500        let entity: Option<AccessUsersGetAccessUsersByUseridTokenByTokenNameError> = serde_json::from_str(&content).ok();
501        Err(Error::ResponseError(ResponseContent { status, content, entity }))
502    }
503}
504
505/// List user's API tokens
506pub async fn access_users_get_token(configuration: &configuration::Configuration, userid: &str) -> Result<models::AccessUsersGetTokenResponse, Error<AccessUsersGetTokenError>> {
507    // add a prefix to parameters to efficiently prevent name collisions
508    let p_path_userid = userid;
509
510    let uri_str = format!("{}/access/users/{userid}/token", configuration.base_path, userid=crate::apis::urlencode(p_path_userid));
511    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
512
513    if let Some(ref user_agent) = configuration.user_agent {
514        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
515    }
516    if let Some(ref apikey) = configuration.api_key {
517        let key = apikey.key.clone();
518        let value = match apikey.prefix {
519            Some(ref prefix) => format!("{} {}", prefix, key),
520            None => key,
521        };
522        req_builder = req_builder.header("Authorization", value);
523    };
524    if let Some(ref apikey) = configuration.api_key {
525        let key = apikey.key.clone();
526        let value = match apikey.prefix {
527            Some(ref prefix) => format!("{} {}", prefix, key),
528            None => key,
529        };
530        req_builder = req_builder.header("CSRFPreventionToken", value);
531    };
532
533    let req = req_builder.build()?;
534    let resp = configuration.client.execute(req).await?;
535
536    let status = resp.status();
537    let content_type = resp
538        .headers()
539        .get("content-type")
540        .and_then(|v| v.to_str().ok())
541        .unwrap_or("application/octet-stream");
542    let content_type = super::ContentType::from(content_type);
543
544    if !status.is_client_error() && !status.is_server_error() {
545        let content = resp.text().await?;
546        match content_type {
547            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
548            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersGetTokenResponse`"))),
549            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::AccessUsersGetTokenResponse`")))),
550        }
551    } else {
552        let content = resp.text().await?;
553        let entity: Option<AccessUsersGetTokenError> = serde_json::from_str(&content).ok();
554        Err(Error::ResponseError(ResponseContent { status, content, entity }))
555    }
556}
557
558/// List users  Permissions: Returns all or just the logged-in user (/API token owner), depending on privileges.
559pub async fn access_users_get_users(configuration: &configuration::Configuration, include_tokens: Option<bool>) -> Result<models::AccessUsersGetUsersResponse, Error<AccessUsersGetUsersError>> {
560    // add a prefix to parameters to efficiently prevent name collisions
561    let p_query_include_tokens = include_tokens;
562
563    let uri_str = format!("{}/access/users", configuration.base_path);
564    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
565
566    if let Some(ref param_value) = p_query_include_tokens {
567        req_builder = req_builder.query(&[("include_tokens", &param_value.to_string())]);
568    }
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(ref apikey) = configuration.api_key {
573        let key = apikey.key.clone();
574        let value = match apikey.prefix {
575            Some(ref prefix) => format!("{} {}", prefix, key),
576            None => key,
577        };
578        req_builder = req_builder.header("Authorization", value);
579    };
580    if let Some(ref apikey) = configuration.api_key {
581        let key = apikey.key.clone();
582        let value = match apikey.prefix {
583            Some(ref prefix) => format!("{} {}", prefix, key),
584            None => key,
585        };
586        req_builder = req_builder.header("CSRFPreventionToken", value);
587    };
588
589    let req = req_builder.build()?;
590    let resp = configuration.client.execute(req).await?;
591
592    let status = resp.status();
593    let content_type = resp
594        .headers()
595        .get("content-type")
596        .and_then(|v| v.to_str().ok())
597        .unwrap_or("application/octet-stream");
598    let content_type = super::ContentType::from(content_type);
599
600    if !status.is_client_error() && !status.is_server_error() {
601        let content = resp.text().await?;
602        match content_type {
603            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
604            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersGetUsersResponse`"))),
605            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::AccessUsersGetUsersResponse`")))),
606        }
607    } else {
608        let content = resp.text().await?;
609        let entity: Option<AccessUsersGetUsersError> = serde_json::from_str(&content).ok();
610        Err(Error::ResponseError(ResponseContent { status, content, entity }))
611    }
612}
613
614/// Update user's API token metadata
615pub async fn access_users_update_token(configuration: &configuration::Configuration, token_name: &str, userid: &str, access_users_update_token_request: Option<models::AccessUsersUpdateTokenRequest>) -> Result<models::AccessUsersUpdateTokenResponse, Error<AccessUsersUpdateTokenError>> {
616    // add a prefix to parameters to efficiently prevent name collisions
617    let p_path_token_name = token_name;
618    let p_path_userid = userid;
619    let p_body_access_users_update_token_request = access_users_update_token_request;
620
621    let uri_str = format!("{}/access/users/{userid}/token/{token_name}", configuration.base_path, token_name=crate::apis::urlencode(p_path_token_name), userid=crate::apis::urlencode(p_path_userid));
622    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
623
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(ref apikey) = configuration.api_key {
628        let key = apikey.key.clone();
629        let value = match apikey.prefix {
630            Some(ref prefix) => format!("{} {}", prefix, key),
631            None => key,
632        };
633        req_builder = req_builder.header("Authorization", value);
634    };
635    if let Some(ref apikey) = configuration.api_key {
636        let key = apikey.key.clone();
637        let value = match apikey.prefix {
638            Some(ref prefix) => format!("{} {}", prefix, key),
639            None => key,
640        };
641        req_builder = req_builder.header("CSRFPreventionToken", value);
642    };
643    req_builder = req_builder.json(&p_body_access_users_update_token_request);
644
645    let req = req_builder.build()?;
646    let resp = configuration.client.execute(req).await?;
647
648    let status = resp.status();
649    let content_type = resp
650        .headers()
651        .get("content-type")
652        .and_then(|v| v.to_str().ok())
653        .unwrap_or("application/octet-stream");
654    let content_type = super::ContentType::from(content_type);
655
656    if !status.is_client_error() && !status.is_server_error() {
657        let content = resp.text().await?;
658        match content_type {
659            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
660            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersUpdateTokenResponse`"))),
661            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::AccessUsersUpdateTokenResponse`")))),
662        }
663    } else {
664        let content = resp.text().await?;
665        let entity: Option<AccessUsersUpdateTokenError> = serde_json::from_str(&content).ok();
666        Err(Error::ResponseError(ResponseContent { status, content, entity }))
667    }
668}
669
670/// Unlock a user's TFA authentication.
671pub async fn access_users_update_unlock_tfa(configuration: &configuration::Configuration, userid: &str) -> Result<models::AccessUsersUpdateUnlockTfaResponse, Error<AccessUsersUpdateUnlockTfaError>> {
672    // add a prefix to parameters to efficiently prevent name collisions
673    let p_path_userid = userid;
674
675    let uri_str = format!("{}/access/users/{userid}/unlock-tfa", configuration.base_path, userid=crate::apis::urlencode(p_path_userid));
676    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
677
678    if let Some(ref user_agent) = configuration.user_agent {
679        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
680    }
681    if let Some(ref apikey) = configuration.api_key {
682        let key = apikey.key.clone();
683        let value = match apikey.prefix {
684            Some(ref prefix) => format!("{} {}", prefix, key),
685            None => key,
686        };
687        req_builder = req_builder.header("Authorization", value);
688    };
689    if let Some(ref apikey) = configuration.api_key {
690        let key = apikey.key.clone();
691        let value = match apikey.prefix {
692            Some(ref prefix) => format!("{} {}", prefix, key),
693            None => key,
694        };
695        req_builder = req_builder.header("CSRFPreventionToken", value);
696    };
697
698    let req = req_builder.build()?;
699    let resp = configuration.client.execute(req).await?;
700
701    let status = resp.status();
702    let content_type = resp
703        .headers()
704        .get("content-type")
705        .and_then(|v| v.to_str().ok())
706        .unwrap_or("application/octet-stream");
707    let content_type = super::ContentType::from(content_type);
708
709    if !status.is_client_error() && !status.is_server_error() {
710        let content = resp.text().await?;
711        match content_type {
712            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
713            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersUpdateUnlockTfaResponse`"))),
714            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::AccessUsersUpdateUnlockTfaResponse`")))),
715        }
716    } else {
717        let content = resp.text().await?;
718        let entity: Option<AccessUsersUpdateUnlockTfaError> = serde_json::from_str(&content).ok();
719        Err(Error::ResponseError(ResponseContent { status, content, entity }))
720    }
721}
722
723/// Update user configuration. To change a user's password use the 'PUT /access/password' endpoint.
724pub async fn access_users_update_users(configuration: &configuration::Configuration, userid: &str, access_users_update_users_request: Option<models::AccessUsersUpdateUsersRequest>) -> Result<models::AccessUsersUpdateUsersResponse, Error<AccessUsersUpdateUsersError>> {
725    // add a prefix to parameters to efficiently prevent name collisions
726    let p_path_userid = userid;
727    let p_body_access_users_update_users_request = access_users_update_users_request;
728
729    let uri_str = format!("{}/access/users/{userid}", configuration.base_path, userid=crate::apis::urlencode(p_path_userid));
730    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
731
732    if let Some(ref user_agent) = configuration.user_agent {
733        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
734    }
735    if let Some(ref apikey) = configuration.api_key {
736        let key = apikey.key.clone();
737        let value = match apikey.prefix {
738            Some(ref prefix) => format!("{} {}", prefix, key),
739            None => key,
740        };
741        req_builder = req_builder.header("Authorization", value);
742    };
743    if let Some(ref apikey) = configuration.api_key {
744        let key = apikey.key.clone();
745        let value = match apikey.prefix {
746            Some(ref prefix) => format!("{} {}", prefix, key),
747            None => key,
748        };
749        req_builder = req_builder.header("CSRFPreventionToken", value);
750    };
751    req_builder = req_builder.json(&p_body_access_users_update_users_request);
752
753    let req = req_builder.build()?;
754    let resp = configuration.client.execute(req).await?;
755
756    let status = resp.status();
757    let content_type = resp
758        .headers()
759        .get("content-type")
760        .and_then(|v| v.to_str().ok())
761        .unwrap_or("application/octet-stream");
762    let content_type = super::ContentType::from(content_type);
763
764    if !status.is_client_error() && !status.is_server_error() {
765        let content = resp.text().await?;
766        match content_type {
767            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
768            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccessUsersUpdateUsersResponse`"))),
769            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::AccessUsersUpdateUsersResponse`")))),
770        }
771    } else {
772        let content = resp.text().await?;
773        let entity: Option<AccessUsersUpdateUsersError> = serde_json::from_str(&content).ok();
774        Err(Error::ResponseError(ResponseContent { status, content, entity }))
775    }
776}
777
clientapi_pbs/apis/access_users_api.rs

clientapi_pbs/apis/
access_users_api.rs
