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 OrganizationSponsorshipsApi: Send + Sync {
29 async fn admin_initiated_revoke_sponsorship<'a>(
31 &self,
32 organization_id: uuid::Uuid,
33 sponsored_friendly_name: &'a str,
34 ) -> Result<(), Error>;
35
36 async fn create_sponsorship<'a>(
38 &self,
39 sponsoring_org_id: uuid::Uuid,
40 organization_sponsorship_create_request_model: Option<
41 models::OrganizationSponsorshipCreateRequestModel,
42 >,
43 ) -> Result<(), Error>;
44
45 async fn get_sponsored_organizations<'a>(
47 &self,
48 sponsoring_org_id: uuid::Uuid,
49 ) -> Result<models::OrganizationSponsorshipInvitesResponseModelListResponseModel, Error>;
50
51 async fn get_sync_status<'a>(&self, sponsoring_org_id: uuid::Uuid) -> Result<(), Error>;
53
54 async fn pre_validate_sponsorship_token<'a>(
56 &self,
57 sponsorship_token: Option<&'a str>,
58 ) -> Result<models::PreValidateSponsorshipResponseModel, Error>;
59
60 async fn redeem_sponsorship<'a>(
62 &self,
63 sponsorship_token: Option<&'a str>,
64 organization_sponsorship_redeem_request_model: Option<
65 models::OrganizationSponsorshipRedeemRequestModel,
66 >,
67 ) -> Result<(), Error>;
68
69 async fn remove_sponsorship<'a>(&self, sponsored_org_id: uuid::Uuid) -> Result<(), Error>;
71
72 async fn resend_sponsorship_offer<'a>(
74 &self,
75 organization_id: uuid::Uuid,
76 sponsored_friendly_name: Option<&'a str>,
77 ) -> Result<(), Error>;
78
79 async fn revoke_sponsorship<'a>(
81 &self,
82 sponsoring_organization_id: uuid::Uuid,
83 ) -> Result<(), Error>;
84
85 async fn sync<'a>(
87 &self,
88 organization_sponsorship_sync_request_model: Option<
89 models::OrganizationSponsorshipSyncRequestModel,
90 >,
91 ) -> Result<models::OrganizationSponsorshipSyncResponseModel, Error>;
92}
93
94pub struct OrganizationSponsorshipsApiClient {
95 configuration: Arc<configuration::Configuration>,
96}
97
98impl OrganizationSponsorshipsApiClient {
99 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
100 Self { configuration }
101 }
102}
103
104#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
105#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
106impl OrganizationSponsorshipsApi for OrganizationSponsorshipsApiClient {
107 async fn admin_initiated_revoke_sponsorship<'a>(
108 &self,
109 organization_id: uuid::Uuid,
110 sponsored_friendly_name: &'a str,
111 ) -> Result<(), Error> {
112 let local_var_configuration = &self.configuration;
113
114 let local_var_client = &local_var_configuration.client;
115
116 let local_var_uri_str = format!(
117 "{}/organization/sponsorship/{organizationId}/{sponsoredFriendlyName}/revoke",
118 local_var_configuration.base_path,
119 organizationId = organization_id,
120 sponsoredFriendlyName = crate::apis::urlencode(sponsored_friendly_name)
121 );
122 let mut local_var_req_builder =
123 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
124
125 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
126
127 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
128 }
129
130 async fn create_sponsorship<'a>(
131 &self,
132 sponsoring_org_id: uuid::Uuid,
133 organization_sponsorship_create_request_model: Option<
134 models::OrganizationSponsorshipCreateRequestModel,
135 >,
136 ) -> Result<(), Error> {
137 let local_var_configuration = &self.configuration;
138
139 let local_var_client = &local_var_configuration.client;
140
141 let local_var_uri_str = format!(
142 "{}/organization/sponsorship/{sponsoringOrgId}/families-for-enterprise",
143 local_var_configuration.base_path,
144 sponsoringOrgId = sponsoring_org_id
145 );
146 let mut local_var_req_builder =
147 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
148
149 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
150 local_var_req_builder =
151 local_var_req_builder.json(&organization_sponsorship_create_request_model);
152
153 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
154 }
155
156 async fn get_sponsored_organizations<'a>(
157 &self,
158 sponsoring_org_id: uuid::Uuid,
159 ) -> Result<models::OrganizationSponsorshipInvitesResponseModelListResponseModel, Error> {
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 "{}/organization/sponsorship/{sponsoringOrgId}/sponsored",
166 local_var_configuration.base_path,
167 sponsoringOrgId = sponsoring_org_id
168 );
169 let mut local_var_req_builder =
170 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
171
172 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
173
174 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
175 }
176
177 async fn get_sync_status<'a>(&self, sponsoring_org_id: uuid::Uuid) -> Result<(), Error> {
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 "{}/organization/sponsorship/{sponsoringOrgId}/sync-status",
184 local_var_configuration.base_path,
185 sponsoringOrgId = sponsoring_org_id
186 );
187 let mut local_var_req_builder =
188 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
189
190 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
191
192 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
193 }
194
195 async fn pre_validate_sponsorship_token<'a>(
196 &self,
197 sponsorship_token: Option<&'a str>,
198 ) -> Result<models::PreValidateSponsorshipResponseModel, Error> {
199 let local_var_configuration = &self.configuration;
200
201 let local_var_client = &local_var_configuration.client;
202
203 let local_var_uri_str = format!(
204 "{}/organization/sponsorship/validate-token",
205 local_var_configuration.base_path
206 );
207 let mut local_var_req_builder =
208 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
209
210 if let Some(ref param_value) = sponsorship_token {
211 local_var_req_builder =
212 local_var_req_builder.query(&[("sponsorshipToken", ¶m_value.to_string())]);
213 }
214 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
215
216 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
217 }
218
219 async fn redeem_sponsorship<'a>(
220 &self,
221 sponsorship_token: Option<&'a str>,
222 organization_sponsorship_redeem_request_model: Option<
223 models::OrganizationSponsorshipRedeemRequestModel,
224 >,
225 ) -> Result<(), Error> {
226 let local_var_configuration = &self.configuration;
227
228 let local_var_client = &local_var_configuration.client;
229
230 let local_var_uri_str = format!(
231 "{}/organization/sponsorship/redeem",
232 local_var_configuration.base_path
233 );
234 let mut local_var_req_builder =
235 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
236
237 if let Some(ref param_value) = sponsorship_token {
238 local_var_req_builder =
239 local_var_req_builder.query(&[("sponsorshipToken", ¶m_value.to_string())]);
240 }
241 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
242 local_var_req_builder =
243 local_var_req_builder.json(&organization_sponsorship_redeem_request_model);
244
245 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
246 }
247
248 async fn remove_sponsorship<'a>(&self, sponsored_org_id: uuid::Uuid) -> Result<(), Error> {
249 let local_var_configuration = &self.configuration;
250
251 let local_var_client = &local_var_configuration.client;
252
253 let local_var_uri_str = format!(
254 "{}/organization/sponsorship/sponsored/{sponsoredOrgId}",
255 local_var_configuration.base_path,
256 sponsoredOrgId = sponsored_org_id
257 );
258 let mut local_var_req_builder =
259 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
260
261 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
262
263 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
264 }
265
266 async fn resend_sponsorship_offer<'a>(
267 &self,
268 organization_id: uuid::Uuid,
269 sponsored_friendly_name: Option<&'a str>,
270 ) -> Result<(), Error> {
271 let local_var_configuration = &self.configuration;
272
273 let local_var_client = &local_var_configuration.client;
274
275 let local_var_uri_str = format!(
276 "{}/organization/sponsorship/{organizationId}/families-for-enterprise/resend",
277 local_var_configuration.base_path,
278 organizationId = organization_id
279 );
280 let mut local_var_req_builder =
281 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
282
283 if let Some(ref param_value) = sponsored_friendly_name {
284 local_var_req_builder =
285 local_var_req_builder.query(&[("sponsoredFriendlyName", ¶m_value.to_string())]);
286 }
287 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
288
289 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
290 }
291
292 async fn revoke_sponsorship<'a>(
293 &self,
294 sponsoring_organization_id: uuid::Uuid,
295 ) -> Result<(), Error> {
296 let local_var_configuration = &self.configuration;
297
298 let local_var_client = &local_var_configuration.client;
299
300 let local_var_uri_str = format!(
301 "{}/organization/sponsorship/{sponsoringOrganizationId}",
302 local_var_configuration.base_path,
303 sponsoringOrganizationId = sponsoring_organization_id
304 );
305 let mut local_var_req_builder =
306 local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
307
308 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
309
310 bitwarden_api_base::process_with_empty_response(local_var_req_builder).await
311 }
312
313 async fn sync<'a>(
314 &self,
315 organization_sponsorship_sync_request_model: Option<
316 models::OrganizationSponsorshipSyncRequestModel,
317 >,
318 ) -> Result<models::OrganizationSponsorshipSyncResponseModel, Error> {
319 let local_var_configuration = &self.configuration;
320
321 let local_var_client = &local_var_configuration.client;
322
323 let local_var_uri_str = format!(
324 "{}/organization/sponsorship/sync",
325 local_var_configuration.base_path
326 );
327 let mut local_var_req_builder =
328 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
329
330 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
331 local_var_req_builder =
332 local_var_req_builder.json(&organization_sponsorship_sync_request_model);
333
334 bitwarden_api_base::process_with_json_response(local_var_req_builder).await
335 }
336}