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 SelfHostedOrganizationBillingVNextApi: Send + Sync {
29 async fn get_metadata<'a>(
31 &self,
32 organization_id: &'a str,
33 id: Option<uuid::Uuid>,
34 identifier: Option<&'a str>,
35 name: Option<&'a str>,
36 business_name: Option<&'a str>,
37 business_address1: Option<&'a str>,
38 business_address2: Option<&'a str>,
39 business_address3: Option<&'a str>,
40 business_country: Option<&'a str>,
41 business_tax_number: Option<&'a str>,
42 billing_email: Option<&'a str>,
43 plan: Option<&'a str>,
44 plan_type: Option<models::PlanType>,
45 seats: Option<i32>,
46 max_collections: Option<i32>,
47 use_policies: Option<bool>,
48 use_sso: Option<bool>,
49 use_key_connector: Option<bool>,
50 use_scim: Option<bool>,
51 use_groups: Option<bool>,
52 use_directory: Option<bool>,
53 use_events: Option<bool>,
54 use_totp: Option<bool>,
55 use2fa: Option<bool>,
56 use_api: Option<bool>,
57 use_reset_password: Option<bool>,
58 use_secrets_manager: Option<bool>,
59 self_host: Option<bool>,
60 users_get_premium: Option<bool>,
61 use_custom_permissions: Option<bool>,
62 storage: Option<i64>,
63 max_storage_gb: Option<i32>,
64 gateway: Option<models::GatewayType>,
65 gateway_customer_id: Option<&'a str>,
66 gateway_subscription_id: Option<&'a str>,
67 reference_data: Option<&'a str>,
68 enabled: Option<bool>,
69 license_key: Option<&'a str>,
70 public_key: Option<&'a str>,
71 private_key: Option<&'a str>,
72 two_factor_providers: Option<&'a str>,
73 expiration_date: Option<String>,
74 creation_date: Option<String>,
75 revision_date: Option<String>,
76 max_autoscale_seats: Option<i32>,
77 owners_notified_of_autoscaling: Option<String>,
78 status: Option<models::OrganizationStatusType>,
79 use_password_manager: Option<bool>,
80 sm_seats: Option<i32>,
81 sm_service_accounts: Option<i32>,
82 max_autoscale_sm_seats: Option<i32>,
83 max_autoscale_sm_service_accounts: Option<i32>,
84 limit_collection_creation: Option<bool>,
85 limit_collection_deletion: Option<bool>,
86 allow_admin_access_to_all_collection_items: Option<bool>,
87 limit_item_deletion: Option<bool>,
88 use_risk_insights: Option<bool>,
89 use_organization_domains: Option<bool>,
90 use_admin_sponsored_families: Option<bool>,
91 sync_seats: Option<bool>,
92 use_automatic_user_confirmation: Option<bool>,
93 use_disable_sm_ads_for_users: Option<bool>,
94 use_phishing_blocker: Option<bool>,
95 ) -> Result<(), Error<GetMetadataError>>;
96}
97
98pub struct SelfHostedOrganizationBillingVNextApiClient {
99 configuration: Arc<configuration::Configuration>,
100}
101
102impl SelfHostedOrganizationBillingVNextApiClient {
103 pub fn new(configuration: Arc<configuration::Configuration>) -> Self {
104 Self { configuration }
105 }
106}
107
108#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
109#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
110impl SelfHostedOrganizationBillingVNextApi for SelfHostedOrganizationBillingVNextApiClient {
111 async fn get_metadata<'a>(
112 &self,
113 organization_id: &'a str,
114 id: Option<uuid::Uuid>,
115 identifier: Option<&'a str>,
116 name: Option<&'a str>,
117 business_name: Option<&'a str>,
118 business_address1: Option<&'a str>,
119 business_address2: Option<&'a str>,
120 business_address3: Option<&'a str>,
121 business_country: Option<&'a str>,
122 business_tax_number: Option<&'a str>,
123 billing_email: Option<&'a str>,
124 plan: Option<&'a str>,
125 plan_type: Option<models::PlanType>,
126 seats: Option<i32>,
127 max_collections: Option<i32>,
128 use_policies: Option<bool>,
129 use_sso: Option<bool>,
130 use_key_connector: Option<bool>,
131 use_scim: Option<bool>,
132 use_groups: Option<bool>,
133 use_directory: Option<bool>,
134 use_events: Option<bool>,
135 use_totp: Option<bool>,
136 use2fa: Option<bool>,
137 use_api: Option<bool>,
138 use_reset_password: Option<bool>,
139 use_secrets_manager: Option<bool>,
140 self_host: Option<bool>,
141 users_get_premium: Option<bool>,
142 use_custom_permissions: Option<bool>,
143 storage: Option<i64>,
144 max_storage_gb: Option<i32>,
145 gateway: Option<models::GatewayType>,
146 gateway_customer_id: Option<&'a str>,
147 gateway_subscription_id: Option<&'a str>,
148 reference_data: Option<&'a str>,
149 enabled: Option<bool>,
150 license_key: Option<&'a str>,
151 public_key: Option<&'a str>,
152 private_key: Option<&'a str>,
153 two_factor_providers: Option<&'a str>,
154 expiration_date: Option<String>,
155 creation_date: Option<String>,
156 revision_date: Option<String>,
157 max_autoscale_seats: Option<i32>,
158 owners_notified_of_autoscaling: Option<String>,
159 status: Option<models::OrganizationStatusType>,
160 use_password_manager: Option<bool>,
161 sm_seats: Option<i32>,
162 sm_service_accounts: Option<i32>,
163 max_autoscale_sm_seats: Option<i32>,
164 max_autoscale_sm_service_accounts: Option<i32>,
165 limit_collection_creation: Option<bool>,
166 limit_collection_deletion: Option<bool>,
167 allow_admin_access_to_all_collection_items: Option<bool>,
168 limit_item_deletion: Option<bool>,
169 use_risk_insights: Option<bool>,
170 use_organization_domains: Option<bool>,
171 use_admin_sponsored_families: Option<bool>,
172 sync_seats: Option<bool>,
173 use_automatic_user_confirmation: Option<bool>,
174 use_disable_sm_ads_for_users: Option<bool>,
175 use_phishing_blocker: Option<bool>,
176 ) -> Result<(), Error<GetMetadataError>> {
177 let local_var_configuration = &self.configuration;
178
179 let local_var_client = &local_var_configuration.client;
180
181 let local_var_uri_str = format!(
182 "{}/organizations/{organizationId}/billing/vnext/self-host/metadata",
183 local_var_configuration.base_path,
184 organizationId = crate::apis::urlencode(organization_id)
185 );
186 let mut local_var_req_builder =
187 local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
188
189 if let Some(ref param_value) = id {
190 local_var_req_builder =
191 local_var_req_builder.query(&[("id", ¶m_value.to_string())]);
192 }
193 if let Some(ref param_value) = identifier {
194 local_var_req_builder =
195 local_var_req_builder.query(&[("identifier", ¶m_value.to_string())]);
196 }
197 if let Some(ref param_value) = name {
198 local_var_req_builder =
199 local_var_req_builder.query(&[("name", ¶m_value.to_string())]);
200 }
201 if let Some(ref param_value) = business_name {
202 local_var_req_builder =
203 local_var_req_builder.query(&[("businessName", ¶m_value.to_string())]);
204 }
205 if let Some(ref param_value) = business_address1 {
206 local_var_req_builder =
207 local_var_req_builder.query(&[("businessAddress1", ¶m_value.to_string())]);
208 }
209 if let Some(ref param_value) = business_address2 {
210 local_var_req_builder =
211 local_var_req_builder.query(&[("businessAddress2", ¶m_value.to_string())]);
212 }
213 if let Some(ref param_value) = business_address3 {
214 local_var_req_builder =
215 local_var_req_builder.query(&[("businessAddress3", ¶m_value.to_string())]);
216 }
217 if let Some(ref param_value) = business_country {
218 local_var_req_builder =
219 local_var_req_builder.query(&[("businessCountry", ¶m_value.to_string())]);
220 }
221 if let Some(ref param_value) = business_tax_number {
222 local_var_req_builder =
223 local_var_req_builder.query(&[("businessTaxNumber", ¶m_value.to_string())]);
224 }
225 if let Some(ref param_value) = billing_email {
226 local_var_req_builder =
227 local_var_req_builder.query(&[("billingEmail", ¶m_value.to_string())]);
228 }
229 if let Some(ref param_value) = plan {
230 local_var_req_builder =
231 local_var_req_builder.query(&[("plan", ¶m_value.to_string())]);
232 }
233 if let Some(ref param_value) = plan_type {
234 local_var_req_builder =
235 local_var_req_builder.query(&[("planType", ¶m_value.to_string())]);
236 }
237 if let Some(ref param_value) = seats {
238 local_var_req_builder =
239 local_var_req_builder.query(&[("seats", ¶m_value.to_string())]);
240 }
241 if let Some(ref param_value) = max_collections {
242 local_var_req_builder =
243 local_var_req_builder.query(&[("maxCollections", ¶m_value.to_string())]);
244 }
245 if let Some(ref param_value) = use_policies {
246 local_var_req_builder =
247 local_var_req_builder.query(&[("usePolicies", ¶m_value.to_string())]);
248 }
249 if let Some(ref param_value) = use_sso {
250 local_var_req_builder =
251 local_var_req_builder.query(&[("useSso", ¶m_value.to_string())]);
252 }
253 if let Some(ref param_value) = use_key_connector {
254 local_var_req_builder =
255 local_var_req_builder.query(&[("useKeyConnector", ¶m_value.to_string())]);
256 }
257 if let Some(ref param_value) = use_scim {
258 local_var_req_builder =
259 local_var_req_builder.query(&[("useScim", ¶m_value.to_string())]);
260 }
261 if let Some(ref param_value) = use_groups {
262 local_var_req_builder =
263 local_var_req_builder.query(&[("useGroups", ¶m_value.to_string())]);
264 }
265 if let Some(ref param_value) = use_directory {
266 local_var_req_builder =
267 local_var_req_builder.query(&[("useDirectory", ¶m_value.to_string())]);
268 }
269 if let Some(ref param_value) = use_events {
270 local_var_req_builder =
271 local_var_req_builder.query(&[("useEvents", ¶m_value.to_string())]);
272 }
273 if let Some(ref param_value) = use_totp {
274 local_var_req_builder =
275 local_var_req_builder.query(&[("useTotp", ¶m_value.to_string())]);
276 }
277 if let Some(ref param_value) = use2fa {
278 local_var_req_builder =
279 local_var_req_builder.query(&[("use2fa", ¶m_value.to_string())]);
280 }
281 if let Some(ref param_value) = use_api {
282 local_var_req_builder =
283 local_var_req_builder.query(&[("useApi", ¶m_value.to_string())]);
284 }
285 if let Some(ref param_value) = use_reset_password {
286 local_var_req_builder =
287 local_var_req_builder.query(&[("useResetPassword", ¶m_value.to_string())]);
288 }
289 if let Some(ref param_value) = use_secrets_manager {
290 local_var_req_builder =
291 local_var_req_builder.query(&[("useSecretsManager", ¶m_value.to_string())]);
292 }
293 if let Some(ref param_value) = self_host {
294 local_var_req_builder =
295 local_var_req_builder.query(&[("selfHost", ¶m_value.to_string())]);
296 }
297 if let Some(ref param_value) = users_get_premium {
298 local_var_req_builder =
299 local_var_req_builder.query(&[("usersGetPremium", ¶m_value.to_string())]);
300 }
301 if let Some(ref param_value) = use_custom_permissions {
302 local_var_req_builder =
303 local_var_req_builder.query(&[("useCustomPermissions", ¶m_value.to_string())]);
304 }
305 if let Some(ref param_value) = storage {
306 local_var_req_builder =
307 local_var_req_builder.query(&[("storage", ¶m_value.to_string())]);
308 }
309 if let Some(ref param_value) = max_storage_gb {
310 local_var_req_builder =
311 local_var_req_builder.query(&[("maxStorageGb", ¶m_value.to_string())]);
312 }
313 if let Some(ref param_value) = gateway {
314 local_var_req_builder =
315 local_var_req_builder.query(&[("gateway", ¶m_value.to_string())]);
316 }
317 if let Some(ref param_value) = gateway_customer_id {
318 local_var_req_builder =
319 local_var_req_builder.query(&[("gatewayCustomerId", ¶m_value.to_string())]);
320 }
321 if let Some(ref param_value) = gateway_subscription_id {
322 local_var_req_builder =
323 local_var_req_builder.query(&[("gatewaySubscriptionId", ¶m_value.to_string())]);
324 }
325 if let Some(ref param_value) = reference_data {
326 local_var_req_builder =
327 local_var_req_builder.query(&[("referenceData", ¶m_value.to_string())]);
328 }
329 if let Some(ref param_value) = enabled {
330 local_var_req_builder =
331 local_var_req_builder.query(&[("enabled", ¶m_value.to_string())]);
332 }
333 if let Some(ref param_value) = license_key {
334 local_var_req_builder =
335 local_var_req_builder.query(&[("licenseKey", ¶m_value.to_string())]);
336 }
337 if let Some(ref param_value) = public_key {
338 local_var_req_builder =
339 local_var_req_builder.query(&[("publicKey", ¶m_value.to_string())]);
340 }
341 if let Some(ref param_value) = private_key {
342 local_var_req_builder =
343 local_var_req_builder.query(&[("privateKey", ¶m_value.to_string())]);
344 }
345 if let Some(ref param_value) = two_factor_providers {
346 local_var_req_builder =
347 local_var_req_builder.query(&[("twoFactorProviders", ¶m_value.to_string())]);
348 }
349 if let Some(ref param_value) = expiration_date {
350 local_var_req_builder =
351 local_var_req_builder.query(&[("expirationDate", ¶m_value.to_string())]);
352 }
353 if let Some(ref param_value) = creation_date {
354 local_var_req_builder =
355 local_var_req_builder.query(&[("creationDate", ¶m_value.to_string())]);
356 }
357 if let Some(ref param_value) = revision_date {
358 local_var_req_builder =
359 local_var_req_builder.query(&[("revisionDate", ¶m_value.to_string())]);
360 }
361 if let Some(ref param_value) = max_autoscale_seats {
362 local_var_req_builder =
363 local_var_req_builder.query(&[("maxAutoscaleSeats", ¶m_value.to_string())]);
364 }
365 if let Some(ref param_value) = owners_notified_of_autoscaling {
366 local_var_req_builder = local_var_req_builder
367 .query(&[("ownersNotifiedOfAutoscaling", ¶m_value.to_string())]);
368 }
369 if let Some(ref param_value) = status {
370 local_var_req_builder =
371 local_var_req_builder.query(&[("status", ¶m_value.to_string())]);
372 }
373 if let Some(ref param_value) = use_password_manager {
374 local_var_req_builder =
375 local_var_req_builder.query(&[("usePasswordManager", ¶m_value.to_string())]);
376 }
377 if let Some(ref param_value) = sm_seats {
378 local_var_req_builder =
379 local_var_req_builder.query(&[("smSeats", ¶m_value.to_string())]);
380 }
381 if let Some(ref param_value) = sm_service_accounts {
382 local_var_req_builder =
383 local_var_req_builder.query(&[("smServiceAccounts", ¶m_value.to_string())]);
384 }
385 if let Some(ref param_value) = max_autoscale_sm_seats {
386 local_var_req_builder =
387 local_var_req_builder.query(&[("maxAutoscaleSmSeats", ¶m_value.to_string())]);
388 }
389 if let Some(ref param_value) = max_autoscale_sm_service_accounts {
390 local_var_req_builder = local_var_req_builder
391 .query(&[("maxAutoscaleSmServiceAccounts", ¶m_value.to_string())]);
392 }
393 if let Some(ref param_value) = limit_collection_creation {
394 local_var_req_builder = local_var_req_builder
395 .query(&[("limitCollectionCreation", ¶m_value.to_string())]);
396 }
397 if let Some(ref param_value) = limit_collection_deletion {
398 local_var_req_builder = local_var_req_builder
399 .query(&[("limitCollectionDeletion", ¶m_value.to_string())]);
400 }
401 if let Some(ref param_value) = allow_admin_access_to_all_collection_items {
402 local_var_req_builder = local_var_req_builder.query(&[(
403 "allowAdminAccessToAllCollectionItems",
404 ¶m_value.to_string(),
405 )]);
406 }
407 if let Some(ref param_value) = limit_item_deletion {
408 local_var_req_builder =
409 local_var_req_builder.query(&[("limitItemDeletion", ¶m_value.to_string())]);
410 }
411 if let Some(ref param_value) = use_risk_insights {
412 local_var_req_builder =
413 local_var_req_builder.query(&[("useRiskInsights", ¶m_value.to_string())]);
414 }
415 if let Some(ref param_value) = use_organization_domains {
416 local_var_req_builder = local_var_req_builder
417 .query(&[("useOrganizationDomains", ¶m_value.to_string())]);
418 }
419 if let Some(ref param_value) = use_admin_sponsored_families {
420 local_var_req_builder = local_var_req_builder
421 .query(&[("useAdminSponsoredFamilies", ¶m_value.to_string())]);
422 }
423 if let Some(ref param_value) = sync_seats {
424 local_var_req_builder =
425 local_var_req_builder.query(&[("syncSeats", ¶m_value.to_string())]);
426 }
427 if let Some(ref param_value) = use_automatic_user_confirmation {
428 local_var_req_builder = local_var_req_builder
429 .query(&[("useAutomaticUserConfirmation", ¶m_value.to_string())]);
430 }
431 if let Some(ref param_value) = use_disable_sm_ads_for_users {
432 local_var_req_builder = local_var_req_builder
433 .query(&[("useDisableSmAdsForUsers", ¶m_value.to_string())]);
434 }
435 if let Some(ref param_value) = use_phishing_blocker {
436 local_var_req_builder =
437 local_var_req_builder.query(&[("usePhishingBlocker", ¶m_value.to_string())]);
438 }
439 if let Some(ref local_var_token) = local_var_configuration.oauth_access_token {
440 local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
441 };
442 local_var_req_builder = local_var_req_builder.with_extension(AuthRequired::Bearer);
443
444 let local_var_req = local_var_req_builder.build()?;
445 let local_var_resp = local_var_client.execute(local_var_req).await?;
446
447 let local_var_status = local_var_resp.status();
448 let local_var_content = local_var_resp.text().await?;
449
450 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
451 Ok(())
452 } else {
453 let local_var_entity: Option<GetMetadataError> =
454 serde_json::from_str(&local_var_content).ok();
455 let local_var_error = ResponseContent {
456 status: local_var_status,
457 content: local_var_content,
458 entity: local_var_entity,
459 };
460 Err(Error::ResponseError(local_var_error))
461 }
462 }
463}
464
465#[derive(Debug, Clone, Serialize, Deserialize)]
467#[serde(untagged)]
468pub enum GetMetadataError {
469 UnknownValue(serde_json::Value),
470}