bitwarden_api_api/apis/
auth_requests_api.rs1use 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 AuthRequestsApi: Send + Sync {
29 async fn get<'a>(&self, id: uuid::Uuid) -> Result<models::AuthRequestResponseModel, Error>;
31
32 async fn get_all(&self) -> Result<models::AuthRequestResponseModelListResponseModel, Error>;
34
35 async fn get_pending_auth_requests(
37 &self,
38 ) -> Result<models::PendingAuthRequestResponseModelListResponseModel, Error>;
39
40 async fn get_response<'a>(
42 &self,
43 id: uuid::Uuid,
44 code: Option<&'a str>,
45 ) -> Result<models::AuthRequestResponseModel, Error>;
46
47 async fn post<'a>(
49 &self,
50 auth_request_create_request_model: Option<models::AuthRequestCreateRequestModel>,
51 ) -> Result<models::AuthRequestResponseModel, Error>;
52
53 async fn post_admin_request<'a>(
55 &self,
56 auth_request_create_request_model: Option<models::AuthRequestCreateRequestModel>,
57 ) -> Result<models::AuthRequestResponseModel, Error>;
58
59 async fn put<'a>(
61 &self,
62 id: uuid::Uuid,
63 auth_request_update_request_model: Option<models::AuthRequestUpdateRequestModel>,
64 ) -> Result<models::AuthRequestResponseModel, Error>;
65}
66
67pub struct AuthRequestsApiClient {
68 configuration: Arc<configuration::Configuration>,
69}
70
71impl AuthRequestsApiClient {
72 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
73 Self { configuration }
74 }
75}
76
77#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
78#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
79impl AuthRequestsApi for AuthRequestsApiClient {
80 async fn get<'a>(&self, id: uuid::Uuid) -> Result<models::AuthRequestResponseModel, Error> {
81 let local_var_configuration = &self.configuration;
82
83 let local_var_client = &local_var_configuration.client;
84
85 let local_var_uri_str = format!(
86 "{}/auth-requests/{id}",
87 local_var_configuration.base_path,
88 id = id
89 );
90 let mut local_var_req_builder =
91 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
92
93 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
94
95 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
96 }
97
98 async fn get_all(&self) -> Result<models::AuthRequestResponseModelListResponseModel, Error> {
99 let local_var_configuration = &self.configuration;
100
101 let local_var_client = &local_var_configuration.client;
102
103 let local_var_uri_str = format!("{}/auth-requests", local_var_configuration.base_path);
104 let mut local_var_req_builder =
105 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
106
107 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
108
109 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
110 }
111
112 async fn get_pending_auth_requests(
113 &self,
114 ) -> Result<models::PendingAuthRequestResponseModelListResponseModel, Error> {
115 let local_var_configuration = &self.configuration;
116
117 let local_var_client = &local_var_configuration.client;
118
119 let local_var_uri_str = format!(
120 "{}/auth-requests/pending",
121 local_var_configuration.base_path
122 );
123 let mut local_var_req_builder =
124 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
125
126 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
127
128 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
129 }
130
131 async fn get_response<'a>(
132 &self,
133 id: uuid::Uuid,
134 code: Option<&'a str>,
135 ) -> Result<models::AuthRequestResponseModel, Error> {
136 let local_var_configuration = &self.configuration;
137
138 let local_var_client = &local_var_configuration.client;
139
140 let local_var_uri_str = format!(
141 "{}/auth-requests/{id}/response",
142 local_var_configuration.base_path,
143 id = id
144 );
145 let mut local_var_req_builder =
146 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
147
148 if let Some(ref param_value) = code {
149 local_var_req_builder =
150 local_var_req_builder.query(&[("code", ¶m_value.to_string())]);
151 }
152 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
153
154 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
155 }
156
157 async fn post<'a>(
158 &self,
159 auth_request_create_request_model: Option<models::AuthRequestCreateRequestModel>,
160 ) -> Result<models::AuthRequestResponseModel, Error> {
161 let local_var_configuration = &self.configuration;
162
163 let local_var_client = &local_var_configuration.client;
164
165 let local_var_uri_str = format!("{}/auth-requests", local_var_configuration.base_path);
166 let mut local_var_req_builder =
167 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
168
169 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
170 local_var_req_builder = local_var_req_builder.json(&auth_request_create_request_model);
171
172 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
173 }
174
175 async fn post_admin_request<'a>(
176 &self,
177 auth_request_create_request_model: Option<models::AuthRequestCreateRequestModel>,
178 ) -> Result<models::AuthRequestResponseModel, Error> {
179 let local_var_configuration = &self.configuration;
180
181 let local_var_client = &local_var_configuration.client;
182
183 let local_var_uri_str = format!(
184 "{}/auth-requests/admin-request",
185 local_var_configuration.base_path
186 );
187 let mut local_var_req_builder =
188 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
189
190 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
191 local_var_req_builder = local_var_req_builder.json(&auth_request_create_request_model);
192
193 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
194 }
195
196 async fn put<'a>(
197 &self,
198 id: uuid::Uuid,
199 auth_request_update_request_model: Option<models::AuthRequestUpdateRequestModel>,
200 ) -> Result<models::AuthRequestResponseModel, Error> {
201 let local_var_configuration = &self.configuration;
202
203 let local_var_client = &local_var_configuration.client;
204
205 let local_var_uri_str = format!(
206 "{}/auth-requests/{id}",
207 local_var_configuration.base_path,
208 id = id
209 );
210 let mut local_var_req_builder =
211 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
212
213 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
214 local_var_req_builder = local_var_req_builder.json(&auth_request_update_request_model);
215
216 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
217 }
218}