bitwarden_api_api/apis/
providers_api.rs

1/*
2 * Bitwarden Internal API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: latest
7 *
8 * Generated by: https://openapi-generator.tech
9 */
10
11use std::sync::Arc;
12
13use async_trait::async_trait;
14#[cfg(feature = "mockall")]
15use mockall::automock;
16use reqwest;
17use serde::{Deserialize, Serialize, de::Error as _};
18
19use super::{Error, configuration};
20use crate::{
21    apis::{AuthRequired, ContentType, ResponseContent},
22    models,
23};
24
25#[cfg_attr(feature = "mockall", automock)]
26#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
27#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
28pub trait ProvidersApi: Send + Sync {
29    /// DELETE /providers/{id}
30    async fn delete<'a>(&self, id: uuid::Uuid) -> Result<(), Error<DeleteError>>;
31
32    /// GET /providers/{id}
33    async fn get<'a>(
34        &self,
35        id: uuid::Uuid,
36    ) -> Result<models::ProviderResponseModel, Error<GetError>>;
37
38    /// POST /providers/{id}/delete-recover-token
39    async fn post_delete_recover_token<'a>(
40        &self,
41        id: uuid::Uuid,
42        provider_verify_delete_recover_request_model: Option<
43            models::ProviderVerifyDeleteRecoverRequestModel,
44        >,
45    ) -> Result<(), Error<PostDeleteRecoverTokenError>>;
46
47    /// PUT /providers/{id}
48    async fn put<'a>(
49        &self,
50        id: uuid::Uuid,
51        provider_update_request_model: Option<models::ProviderUpdateRequestModel>,
52    ) -> Result<models::ProviderResponseModel, Error<PutError>>;
53
54    /// POST /providers/{id}/setup
55    async fn setup<'a>(
56        &self,
57        id: uuid::Uuid,
58        provider_setup_request_model: Option<models::ProviderSetupRequestModel>,
59    ) -> Result<models::ProviderResponseModel, Error<SetupError>>;
60}
61
62pub struct ProvidersApiClient {
63    configuration: Arc<configuration::Configuration>,
64}
65
66impl ProvidersApiClient {
67    pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
68        Self { configuration }
69    }
70}
71
72#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
73#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
74impl ProvidersApi for ProvidersApiClient {
75    async fn delete<'a>(&self, id: uuid::Uuid) -> Result<(), Error<DeleteError>> {
76        let local_var_configuration = &self.configuration;
77
78        let local_var_client = &local_var_configuration.client;
79
80        let local_var_uri_str = format!(
81            "{}/providers/{id}",
82            local_var_configuration.base_path,
83            id = id
84        );
85        let mut local_var_req_builder =
86            local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
87
88        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
89            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
90        };
91        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
92
93        let local_var_req = local_var_req_builder.build()?;
94        let local_var_resp = local_var_client.execute(local_var_req).await?;
95
96        let local_var_status = local_var_resp.status();
97        let local_var_content = local_var_resp.text().await?;
98
99        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
100            Ok(())
101        } else {
102            let local_var_entity: Option<DeleteError> =
103                serde_json::from_str(&local_var_content).ok();
104            let local_var_error = ResponseContent {
105                status: local_var_status,
106                content: local_var_content,
107                entity: local_var_entity,
108            };
109            Err(Error::ResponseError(local_var_error))
110        }
111    }
112
113    async fn get<'a>(
114        &self,
115        id: uuid::Uuid,
116    ) -> Result<models::ProviderResponseModel, Error<GetError>> {
117        let local_var_configuration = &self.configuration;
118
119        let local_var_client = &local_var_configuration.client;
120
121        let local_var_uri_str = format!(
122            "{}/providers/{id}",
123            local_var_configuration.base_path,
124            id = id
125        );
126        let mut local_var_req_builder =
127            local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
128
129        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
130            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
131        };
132        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
133
134        let local_var_req = local_var_req_builder.build()?;
135        let local_var_resp = local_var_client.execute(local_var_req).await?;
136
137        let local_var_status = local_var_resp.status();
138        let local_var_content_type = local_var_resp
139            .headers()
140            .get("content-type")
141            .and_then(|v| v.to_str().ok())
142            .unwrap_or("application/octet-stream");
143        let local_var_content_type = super::ContentType::from(local_var_content_type);
144        let local_var_content = local_var_resp.text().await?;
145
146        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
147            match local_var_content_type {
148                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
149                ContentType::Text => {
150                    return Err(Error::from(serde_json::Error::custom(
151                        "Received `text/plain` content type response that cannot be converted to `models::ProviderResponseModel`",
152                    )));
153                }
154                ContentType::Unsupported(local_var_unknown_type) => {
155                    return Err(Error::from(serde_json::Error::custom(format!(
156                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderResponseModel`"
157                    ))));
158                }
159            }
160        } else {
161            let local_var_entity: Option<GetError> = serde_json::from_str(&local_var_content).ok();
162            let local_var_error = ResponseContent {
163                status: local_var_status,
164                content: local_var_content,
165                entity: local_var_entity,
166            };
167            Err(Error::ResponseError(local_var_error))
168        }
169    }
170
171    async fn post_delete_recover_token<'a>(
172        &self,
173        id: uuid::Uuid,
174        provider_verify_delete_recover_request_model: Option<
175            models::ProviderVerifyDeleteRecoverRequestModel,
176        >,
177    ) -> Result<(), Error<PostDeleteRecoverTokenError>> {
178        let local_var_configuration = &self.configuration;
179
180        let local_var_client = &local_var_configuration.client;
181
182        let local_var_uri_str = format!(
183            "{}/providers/{id}/delete-recover-token",
184            local_var_configuration.base_path,
185            id = id
186        );
187        let mut local_var_req_builder =
188            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
189
190        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
191            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
192        };
193        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
194        local_var_req_builder =
195            local_var_req_builder.json(&provider_verify_delete_recover_request_model);
196
197        let local_var_req = local_var_req_builder.build()?;
198        let local_var_resp = local_var_client.execute(local_var_req).await?;
199
200        let local_var_status = local_var_resp.status();
201        let local_var_content = local_var_resp.text().await?;
202
203        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
204            Ok(())
205        } else {
206            let local_var_entity: Option<PostDeleteRecoverTokenError> =
207                serde_json::from_str(&local_var_content).ok();
208            let local_var_error = ResponseContent {
209                status: local_var_status,
210                content: local_var_content,
211                entity: local_var_entity,
212            };
213            Err(Error::ResponseError(local_var_error))
214        }
215    }
216
217    async fn put<'a>(
218        &self,
219        id: uuid::Uuid,
220        provider_update_request_model: Option<models::ProviderUpdateRequestModel>,
221    ) -> Result<models::ProviderResponseModel, Error<PutError>> {
222        let local_var_configuration = &self.configuration;
223
224        let local_var_client = &local_var_configuration.client;
225
226        let local_var_uri_str = format!(
227            "{}/providers/{id}",
228            local_var_configuration.base_path,
229            id = id
230        );
231        let mut local_var_req_builder =
232            local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
233
234        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
235            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
236        };
237        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
238        local_var_req_builder = local_var_req_builder.json(&provider_update_request_model);
239
240        let local_var_req = local_var_req_builder.build()?;
241        let local_var_resp = local_var_client.execute(local_var_req).await?;
242
243        let local_var_status = local_var_resp.status();
244        let local_var_content_type = local_var_resp
245            .headers()
246            .get("content-type")
247            .and_then(|v| v.to_str().ok())
248            .unwrap_or("application/octet-stream");
249        let local_var_content_type = super::ContentType::from(local_var_content_type);
250        let local_var_content = local_var_resp.text().await?;
251
252        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
253            match local_var_content_type {
254                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
255                ContentType::Text => {
256                    return Err(Error::from(serde_json::Error::custom(
257                        "Received `text/plain` content type response that cannot be converted to `models::ProviderResponseModel`",
258                    )));
259                }
260                ContentType::Unsupported(local_var_unknown_type) => {
261                    return Err(Error::from(serde_json::Error::custom(format!(
262                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderResponseModel`"
263                    ))));
264                }
265            }
266        } else {
267            let local_var_entity: Option<PutError> = serde_json::from_str(&local_var_content).ok();
268            let local_var_error = ResponseContent {
269                status: local_var_status,
270                content: local_var_content,
271                entity: local_var_entity,
272            };
273            Err(Error::ResponseError(local_var_error))
274        }
275    }
276
277    async fn setup<'a>(
278        &self,
279        id: uuid::Uuid,
280        provider_setup_request_model: Option<models::ProviderSetupRequestModel>,
281    ) -> Result<models::ProviderResponseModel, Error<SetupError>> {
282        let local_var_configuration = &self.configuration;
283
284        let local_var_client = &local_var_configuration.client;
285
286        let local_var_uri_str = format!(
287            "{}/providers/{id}/setup",
288            local_var_configuration.base_path,
289            id = id
290        );
291        let mut local_var_req_builder =
292            local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
293
294        if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
295            local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
296        };
297        local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
298        local_var_req_builder = local_var_req_builder.json(&provider_setup_request_model);
299
300        let local_var_req = local_var_req_builder.build()?;
301        let local_var_resp = local_var_client.execute(local_var_req).await?;
302
303        let local_var_status = local_var_resp.status();
304        let local_var_content_type = local_var_resp
305            .headers()
306            .get("content-type")
307            .and_then(|v| v.to_str().ok())
308            .unwrap_or("application/octet-stream");
309        let local_var_content_type = super::ContentType::from(local_var_content_type);
310        let local_var_content = local_var_resp.text().await?;
311
312        if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
313            match local_var_content_type {
314                ContentType::Json => serde_json::from_str(&local_var_content).map_err(Error::from),
315                ContentType::Text => {
316                    return Err(Error::from(serde_json::Error::custom(
317                        "Received `text/plain` content type response that cannot be converted to `models::ProviderResponseModel`",
318                    )));
319                }
320                ContentType::Unsupported(local_var_unknown_type) => {
321                    return Err(Error::from(serde_json::Error::custom(format!(
322                        "Received `{local_var_unknown_type}` content type response that cannot be converted to `models::ProviderResponseModel`"
323                    ))));
324                }
325            }
326        } else {
327            let local_var_entity: Option<SetupError> =
328                serde_json::from_str(&local_var_content).ok();
329            let local_var_error = ResponseContent {
330                status: local_var_status,
331                content: local_var_content,
332                entity: local_var_entity,
333            };
334            Err(Error::ResponseError(local_var_error))
335        }
336    }
337}
338
339/// struct for typed errors of method [`ProvidersApi::delete`]
340#[derive(Debug, Clone, Serialize, Deserialize)]
341#[serde(untagged)]
342pub enum DeleteError {
343    UnknownValue(serde_json::Value),
344}
345/// struct for typed errors of method [`ProvidersApi::get`]
346#[derive(Debug, Clone, Serialize, Deserialize)]
347#[serde(untagged)]
348pub enum GetError {
349    UnknownValue(serde_json::Value),
350}
351/// struct for typed errors of method [`ProvidersApi::post_delete_recover_token`]
352#[derive(Debug, Clone, Serialize, Deserialize)]
353#[serde(untagged)]
354pub enum PostDeleteRecoverTokenError {
355    UnknownValue(serde_json::Value),
356}
357/// struct for typed errors of method [`ProvidersApi::put`]
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(untagged)]
360pub enum PutError {
361    UnknownValue(serde_json::Value),
362}
363/// struct for typed errors of method [`ProvidersApi::setup`]
364#[derive(Debug, Clone, Serialize, Deserialize)]
365#[serde(untagged)]
366pub enum SetupError {
367    UnknownValue(serde_json::Value),
368}
bitwarden_api_api/apis/providers_api.rs

bitwarden_api_api/apis/
providers_api.rs
