1use 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 GroupsApi: Send + Sync {
29 async fn bulk_delete<'a>(
31 &self,
32 org_id: &'a str,
33 group_bulk_request_model: Option<models::GroupBulkRequestModel>,
34 ) -> Result<(), Error<BulkDeleteError>>;
35
36 async fn delete<'a>(&self, org_id: &'a str, id: &'a str) -> Result<(), Error<DeleteError>>;
38
39 async fn delete_user<'a>(
41 &self,
42 org_id: &'a str,
43 id: &'a str,
44 org_user_id: &'a str,
45 ) -> Result<(), Error<DeleteUserError>>;
46
47 async fn get<'a>(
49 &self,
50 org_id: &'a str,
51 id: &'a str,
52 ) -> Result<models::GroupResponseModel, Error<GetError>>;
53
54 async fn get_details<'a>(
56 &self,
57 org_id: &'a str,
58 id: &'a str,
59 ) -> Result<models::GroupDetailsResponseModel, Error<GetDetailsError>>;
60
61 async fn get_organization_group_details<'a>(
63 &self,
64 org_id: uuid::Uuid,
65 ) -> Result<
66 models::GroupDetailsResponseModelListResponseModel,
67 Error<GetOrganizationGroupDetailsError>,
68 >;
69
70 async fn get_organization_groups<'a>(
72 &self,
73 org_id: uuid::Uuid,
74 ) -> Result<models::GroupResponseModelListResponseModel, Error<GetOrganizationGroupsError>>;
75
76 async fn get_users<'a>(
78 &self,
79 org_id: &'a str,
80 id: &'a str,
81 ) -> Result<Vec<uuid::Uuid>, Error<GetUsersError>>;
82
83 async fn post<'a>(
85 &self,
86 org_id: uuid::Uuid,
87 group_request_model: Option<models::GroupRequestModel>,
88 ) -> Result<models::GroupResponseModel, Error<PostError>>;
89
90 async fn put<'a>(
92 &self,
93 org_id: uuid::Uuid,
94 id: uuid::Uuid,
95 group_request_model: Option<models::GroupRequestModel>,
96 ) -> Result<models::GroupResponseModel, Error<PutError>>;
97}
98
99pub struct GroupsApiClient {
100 configuration: Arc<configuration::Configuration>,
101}
102
103impl GroupsApiClient {
104 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
105 Self { configuration }
106 }
107}
108
109#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
110#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
111impl GroupsApi for GroupsApiClient {
112 async fn bulk_delete<'a>(
113 &self,
114 org_id: &'a str,
115 group_bulk_request_model: Option<models::GroupBulkRequestModel>,
116 ) -> Result<(), Error<BulkDeleteError>> {
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 "{}/organizations/{orgId}/groups",
123 local_var_configuration.base_path,
124 orgId = crate::apis::urlencode(org_id)
125 );
126 let mut local_var_req_builder =
127 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
128
129 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
130 local_var_req_builder = local_var_req_builder.json(&group_bulk_request_model);
131
132 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
133 }
134
135 async fn delete<'a>(&self, org_id: &'a str, id: &'a str) -> Result<(), Error<DeleteError>> {
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 "{}/organizations/{orgId}/groups/{id}",
142 local_var_configuration.base_path,
143 orgId = crate::apis::urlencode(org_id),
144 id = crate::apis::urlencode(id)
145 );
146 let mut local_var_req_builder =
147 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
148
149 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
150
151 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
152 }
153
154 async fn delete_user<'a>(
155 &self,
156 org_id: &'a str,
157 id: &'a str,
158 org_user_id: &'a str,
159 ) -> Result<(), Error<DeleteUserError>> {
160 let local_var_configuration = &self.configuration;
161
162 let local_var_client = &local_var_configuration.client;
163
164 let local_var_uri_str = format!(
165 "{}/organizations/{orgId}/groups/{id}/user/{orgUserId}",
166 local_var_configuration.base_path,
167 orgId = crate::apis::urlencode(org_id),
168 id = crate::apis::urlencode(id),
169 orgUserId = crate::apis::urlencode(org_user_id)
170 );
171 let mut local_var_req_builder =
172 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
173
174 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
175
176 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
177 }
178
179 async fn get<'a>(
180 &self,
181 org_id: &'a str,
182 id: &'a str,
183 ) -> Result<models::GroupResponseModel, Error<GetError>> {
184 let local_var_configuration = &self.configuration;
185
186 let local_var_client = &local_var_configuration.client;
187
188 let local_var_uri_str = format!(
189 "{}/organizations/{orgId}/groups/{id}",
190 local_var_configuration.base_path,
191 orgId = crate::apis::urlencode(org_id),
192 id = crate::apis::urlencode(id)
193 );
194 let mut local_var_req_builder =
195 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
196
197 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
198
199 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
200 }
201
202 async fn get_details<'a>(
203 &self,
204 org_id: &'a str,
205 id: &'a str,
206 ) -> Result<models::GroupDetailsResponseModel, Error<GetDetailsError>> {
207 let local_var_configuration = &self.configuration;
208
209 let local_var_client = &local_var_configuration.client;
210
211 let local_var_uri_str = format!(
212 "{}/organizations/{orgId}/groups/{id}/details",
213 local_var_configuration.base_path,
214 orgId = crate::apis::urlencode(org_id),
215 id = crate::apis::urlencode(id)
216 );
217 let mut local_var_req_builder =
218 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
219
220 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
221
222 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
223 }
224
225 async fn get_organization_group_details<'a>(
226 &self,
227 org_id: uuid::Uuid,
228 ) -> Result<
229 models::GroupDetailsResponseModelListResponseModel,
230 Error<GetOrganizationGroupDetailsError>,
231 > {
232 let local_var_configuration = &self.configuration;
233
234 let local_var_client = &local_var_configuration.client;
235
236 let local_var_uri_str = format!(
237 "{}/organizations/{orgId}/groups/details",
238 local_var_configuration.base_path,
239 orgId = org_id
240 );
241 let mut local_var_req_builder =
242 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
243
244 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
245
246 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
247 }
248
249 async fn get_organization_groups<'a>(
250 &self,
251 org_id: uuid::Uuid,
252 ) -> Result<models::GroupResponseModelListResponseModel, Error<GetOrganizationGroupsError>>
253 {
254 let local_var_configuration = &self.configuration;
255
256 let local_var_client = &local_var_configuration.client;
257
258 let local_var_uri_str = format!(
259 "{}/organizations/{orgId}/groups",
260 local_var_configuration.base_path,
261 orgId = org_id
262 );
263 let mut local_var_req_builder =
264 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
265
266 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
267
268 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
269 }
270
271 async fn get_users<'a>(
272 &self,
273 org_id: &'a str,
274 id: &'a str,
275 ) -> Result<Vec<uuid::Uuid>, Error<GetUsersError>> {
276 let local_var_configuration = &self.configuration;
277
278 let local_var_client = &local_var_configuration.client;
279
280 let local_var_uri_str = format!(
281 "{}/organizations/{orgId}/groups/{id}/users",
282 local_var_configuration.base_path,
283 orgId = crate::apis::urlencode(org_id),
284 id = crate::apis::urlencode(id)
285 );
286 let mut local_var_req_builder =
287 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
288
289 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
290
291 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
292 }
293
294 async fn post<'a>(
295 &self,
296 org_id: uuid::Uuid,
297 group_request_model: Option<models::GroupRequestModel>,
298 ) -> Result<models::GroupResponseModel, Error<PostError>> {
299 let local_var_configuration = &self.configuration;
300
301 let local_var_client = &local_var_configuration.client;
302
303 let local_var_uri_str = format!(
304 "{}/organizations/{orgId}/groups",
305 local_var_configuration.base_path,
306 orgId = org_id
307 );
308 let mut local_var_req_builder =
309 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
310
311 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
312 local_var_req_builder = local_var_req_builder.json(&group_request_model);
313
314 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
315 }
316
317 async fn put<'a>(
318 &self,
319 org_id: uuid::Uuid,
320 id: uuid::Uuid,
321 group_request_model: Option<models::GroupRequestModel>,
322 ) -> Result<models::GroupResponseModel, Error<PutError>> {
323 let local_var_configuration = &self.configuration;
324
325 let local_var_client = &local_var_configuration.client;
326
327 let local_var_uri_str = format!(
328 "{}/organizations/{orgId}/groups/{id}",
329 local_var_configuration.base_path,
330 orgId = org_id,
331 id = id
332 );
333 let mut local_var_req_builder =
334 local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
335
336 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
337 local_var_req_builder = local_var_req_builder.json(&group_request_model);
338
339 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
340 }
341}
342
343#[derive(Debug, Clone, Serialize, Deserialize)]
345#[serde(untagged)]
346pub enum BulkDeleteError {
347 UnknownValue(serde_json::Value),
348}
349#[derive(Debug, Clone, Serialize, Deserialize)]
351#[serde(untagged)]
352pub enum DeleteError {
353 UnknownValue(serde_json::Value),
354}
355#[derive(Debug, Clone, Serialize, Deserialize)]
357#[serde(untagged)]
358pub enum DeleteUserError {
359 UnknownValue(serde_json::Value),
360}
361#[derive(Debug, Clone, Serialize, Deserialize)]
363#[serde(untagged)]
364pub enum GetError {
365 UnknownValue(serde_json::Value),
366}
367#[derive(Debug, Clone, Serialize, Deserialize)]
369#[serde(untagged)]
370pub enum GetDetailsError {
371 UnknownValue(serde_json::Value),
372}
373#[derive(Debug, Clone, Serialize, Deserialize)]
375#[serde(untagged)]
376pub enum GetOrganizationGroupDetailsError {
377 UnknownValue(serde_json::Value),
378}
379#[derive(Debug, Clone, Serialize, Deserialize)]
381#[serde(untagged)]
382pub enum GetOrganizationGroupsError {
383 UnknownValue(serde_json::Value),
384}
385#[derive(Debug, Clone, Serialize, Deserialize)]
387#[serde(untagged)]
388pub enum GetUsersError {
389 UnknownValue(serde_json::Value),
390}
391#[derive(Debug, Clone, Serialize, Deserialize)]
393#[serde(untagged)]
394pub enum PostError {
395 UnknownValue(serde_json::Value),
396}
397#[derive(Debug, Clone, Serialize, Deserialize)]
399#[serde(untagged)]
400pub enum PutError {
401 UnknownValue(serde_json::Value),
402}