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