1use std::borrow::Borrow;
12use std::rc::Rc;
13
14use futures;
15use futures::Future;
16use hyper;
17
18use super::{configuration, put, query, Error};
19
20pub struct AuthApiClient<C: hyper::client::connect::Connect> {
21 configuration: Rc<configuration::Configuration<C>>,
22}
23
24impl<C: hyper::client::connect::Connect> AuthApiClient<C> {
25 pub fn new(configuration: Rc<configuration::Configuration<C>>) -> AuthApiClient<C> {
26 AuthApiClient {
27 configuration: configuration,
28 }
29 }
30}
31
32pub trait AuthApi {
33 fn create_auth_cache_item(
34 &self,
35 auth_cache_item: crate::models::AuthCacheItem,
36 zone: &str,
37 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
38 fn create_auth_group(
39 &self,
40 auth_group: crate::models::AuthGroupCreateParams,
41 force: bool,
42 zone: &str,
43 provider: &str,
44 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
45 fn create_auth_refresh_item(
46 &self,
47 auth_refresh_item: crate::models::Empty,
48 ) -> Box<dyn Future<Item = crate::models::CreateAuthRefreshItemResponse, Error = Error>>;
49 fn create_auth_role(
50 &self,
51 auth_role: crate::models::AuthRoleCreateParams,
52 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
53 fn create_auth_user(
54 &self,
55 auth_user: crate::models::AuthUserCreateParams,
56 force: bool,
57 zone: &str,
58 provider: &str,
59 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
60 fn create_mapping_identity(
61 &self,
62 mapping_identity: crate::models::MappingIdentityCreateParams,
63 var_2way: bool,
64 zone: &str,
65 replace: bool,
66 ) -> Box<dyn Future<Item = crate::models::Empty, Error = Error>>;
67 fn create_mapping_identity_0(
68 &self,
69 mapping_identity: crate::models::Empty,
70 mapping_identity_id: &str,
71 _type: &str,
72 zone: &str,
73 ) -> Box<dyn Future<Item = crate::models::MappingIdentities, Error = Error>>;
74 fn create_providers_ads_item(
75 &self,
76 providers_ads_item: crate::models::ProvidersAdsItem,
77 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
78 fn create_providers_file_item(
79 &self,
80 providers_file_item: crate::models::ProvidersFileItem,
81 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
82 fn create_providers_krb5_item(
83 &self,
84 providers_krb5_item: crate::models::ProvidersKrb5Item,
85 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
86 fn create_providers_ldap_item(
87 &self,
88 providers_ldap_item: crate::models::ProvidersLdapItem,
89 force: bool,
90 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
91 fn create_providers_nis_item(
92 &self,
93 providers_nis_item: crate::models::ProvidersNisItem,
94 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
95 fn create_settings_krb5_domain(
96 &self,
97 settings_krb5_domain: crate::models::SettingsKrb5DomainCreateParams,
98 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
99 fn create_settings_krb5_realm(
100 &self,
101 settings_krb5_realm: crate::models::SettingsKrb5RealmCreateParams,
102 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>>;
103 fn delete_auth_group(
104 &self,
105 auth_group_id: &str,
106 cached: bool,
107 zone: &str,
108 provider: &str,
109 ) -> Box<dyn Future<Item = (), Error = Error>>;
110 fn delete_auth_groups(
111 &self,
112 cached: bool,
113 zone: &str,
114 provider: &str,
115 ) -> Box<dyn Future<Item = (), Error = Error>>;
116 fn delete_auth_role(&self, auth_role_id: &str) -> Box<dyn Future<Item = (), Error = Error>>;
117 fn delete_auth_user(
118 &self,
119 auth_user_id: &str,
120 cached: bool,
121 zone: &str,
122 provider: &str,
123 ) -> Box<dyn Future<Item = (), Error = Error>>;
124 fn delete_auth_users(
125 &self,
126 cached: bool,
127 zone: &str,
128 provider: &str,
129 ) -> Box<dyn Future<Item = (), Error = Error>>;
130 fn delete_mapping_identities(
131 &self,
132 filter: &str,
133 zone: &str,
134 remove: bool,
135 ) -> Box<dyn Future<Item = (), Error = Error>>;
136 fn delete_mapping_identity(
137 &self,
138 mapping_identity_id: &str,
139 zone: &str,
140 var_2way: bool,
141 target: &str,
142 remove: bool,
143 ) -> Box<dyn Future<Item = (), Error = Error>>;
144 fn delete_providers_ads_by_id(
145 &self,
146 providers_ads_id: &str,
147 ) -> Box<dyn Future<Item = (), Error = Error>>;
148 fn delete_providers_file_by_id(
149 &self,
150 providers_file_id: &str,
151 ) -> Box<dyn Future<Item = (), Error = Error>>;
152 fn delete_providers_krb5_by_id(
153 &self,
154 providers_krb5_id: &str,
155 ) -> Box<dyn Future<Item = (), Error = Error>>;
156 fn delete_providers_ldap_by_id(
157 &self,
158 providers_ldap_id: &str,
159 ) -> Box<dyn Future<Item = (), Error = Error>>;
160 fn delete_providers_local_by_id(
161 &self,
162 providers_local_id: &str,
163 ) -> Box<dyn Future<Item = (), Error = Error>>;
164 fn delete_providers_nis_by_id(
165 &self,
166 providers_nis_id: &str,
167 ) -> Box<dyn Future<Item = (), Error = Error>>;
168 fn delete_settings_krb5_domain(
169 &self,
170 settings_krb5_domain_id: &str,
171 ) -> Box<dyn Future<Item = (), Error = Error>>;
172 fn delete_settings_krb5_realm(
173 &self,
174 settings_krb5_realm_id: &str,
175 ) -> Box<dyn Future<Item = (), Error = Error>>;
176 fn get_auth_access_user(
177 &self,
178 auth_access_user: &str,
179 path: &str,
180 share: &str,
181 zone: &str,
182 numeric: bool,
183 ) -> Box<dyn Future<Item = crate::models::AuthAccess, Error = Error>>;
184 fn get_auth_group(
185 &self,
186 auth_group_id: &str,
187 cached: bool,
188 resolve_names: bool,
189 query_member_of: bool,
190 zone: &str,
191 provider: &str,
192 ) -> Box<dyn Future<Item = crate::models::AuthGroups, Error = Error>>;
193 fn get_auth_id(&self) -> Box<dyn Future<Item = crate::models::AuthId, Error = Error>>;
194 fn get_auth_ldap_template(
195 &self,
196 auth_ldap_template_id: &str,
197 ) -> Box<dyn Future<Item = crate::models::AuthLdapTemplates, Error = Error>>;
198 fn get_auth_ldap_templates(
199 &self,
200 ) -> Box<dyn Future<Item = crate::models::AuthLdapTemplatesExtended, Error = Error>>;
201 fn get_auth_log_level(
202 &self,
203 ) -> Box<dyn Future<Item = crate::models::AuthLogLevel, Error = Error>>;
204 fn get_auth_netgroup(
205 &self,
206 auth_netgroup_id: &str,
207 ignore_errors: bool,
208 recursive: bool,
209 zone: &str,
210 provider: &str,
211 ) -> Box<dyn Future<Item = crate::models::AuthNetgroups, Error = Error>>;
212 fn get_auth_privileges(
213 &self,
214 ) -> Box<dyn Future<Item = crate::models::AuthPrivileges, Error = Error>>;
215 fn get_auth_role(
216 &self,
217 auth_role_id: &str,
218 resolve_names: bool,
219 ) -> Box<dyn Future<Item = crate::models::AuthRoles, Error = Error>>;
220 fn get_auth_shells(&self) -> Box<dyn Future<Item = crate::models::AuthShells, Error = Error>>;
221 fn get_auth_user(
222 &self,
223 auth_user_id: &str,
224 cached: bool,
225 resolve_names: bool,
226 query_member_of: bool,
227 zone: &str,
228 provider: &str,
229 ) -> Box<dyn Future<Item = crate::models::AuthUsers, Error = Error>>;
230 fn get_auth_wellknown(
231 &self,
232 auth_wellknown_id: &str,
233 scope: &str,
234 ) -> Box<dyn Future<Item = crate::models::AuthWellknowns, Error = Error>>;
235 fn get_auth_wellknowns(
236 &self,
237 ) -> Box<dyn Future<Item = crate::models::AuthWellknowns, Error = Error>>;
238 fn get_mapping_dump(
239 &self,
240 nocreate: bool,
241 zone: &str,
242 ) -> Box<dyn Future<Item = crate::models::MappingDump, Error = Error>>;
243 fn get_mapping_identity(
244 &self,
245 mapping_identity_id: &str,
246 nocreate: bool,
247 zone: &str,
248 ) -> Box<dyn Future<Item = crate::models::MappingIdentities, Error = Error>>;
249 fn get_mapping_users_lookup(
250 &self,
251 primary_gid: i32,
252 uid: i32,
253 zone: &str,
254 gid: Vec<i32>,
255 user: &str,
256 kerberos_principal: &str,
257 ) -> Box<dyn Future<Item = crate::models::MappingUsersLookup, Error = Error>>;
258 fn get_mapping_users_rules(
259 &self,
260 zone: &str,
261 ) -> Box<dyn Future<Item = crate::models::MappingUsersRules, Error = Error>>;
262 fn get_providers_ads_by_id(
263 &self,
264 providers_ads_id: &str,
265 scope: &str,
266 ) -> Box<dyn Future<Item = crate::models::ProvidersAds, Error = Error>>;
267 fn get_providers_file_by_id(
268 &self,
269 providers_file_id: &str,
270 scope: &str,
271 ) -> Box<dyn Future<Item = crate::models::ProvidersFile, Error = Error>>;
272 fn get_providers_krb5_by_id(
273 &self,
274 providers_krb5_id: &str,
275 scope: &str,
276 ) -> Box<dyn Future<Item = crate::models::ProvidersKrb5, Error = Error>>;
277 fn get_providers_ldap_by_id(
278 &self,
279 providers_ldap_id: &str,
280 scope: &str,
281 ) -> Box<dyn Future<Item = crate::models::ProvidersLdap, Error = Error>>;
282 fn get_providers_local(
283 &self,
284 scope: &str,
285 ) -> Box<dyn Future<Item = crate::models::ProvidersLocal, Error = Error>>;
286 fn get_providers_local_by_id(
287 &self,
288 providers_local_id: &str,
289 scope: &str,
290 ) -> Box<dyn Future<Item = crate::models::ProvidersLocal, Error = Error>>;
291 fn get_providers_nis_by_id(
292 &self,
293 providers_nis_id: &str,
294 scope: &str,
295 ) -> Box<dyn Future<Item = crate::models::ProvidersNis, Error = Error>>;
296 fn get_providers_summary(
297 &self,
298 groupnet: &str,
299 zone: &str,
300 ) -> Box<dyn Future<Item = crate::models::ProvidersSummary, Error = Error>>;
301 fn get_settings_acls(
302 &self,
303 preset: &str,
304 ) -> Box<dyn Future<Item = crate::models::SettingsAcls, Error = Error>>;
305 fn get_settings_global(
306 &self,
307 scope: &str,
308 zone: &str,
309 ) -> Box<dyn Future<Item = crate::models::SettingsGlobal, Error = Error>>;
310 fn get_settings_krb5_defaults(
311 &self,
312 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Defaults, Error = Error>>;
313 fn get_settings_krb5_domain(
314 &self,
315 settings_krb5_domain_id: &str,
316 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Domains, Error = Error>>;
317 fn get_settings_krb5_realm(
318 &self,
319 settings_krb5_realm_id: &str,
320 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Realms, Error = Error>>;
321 fn get_settings_mapping(
322 &self,
323 scope: &str,
324 zone: &str,
325 ) -> Box<dyn Future<Item = crate::models::SettingsMapping, Error = Error>>;
326 fn list_auth_groups(
327 &self,
328 domain: &str,
329 zone: &str,
330 resume: &str,
331 cached: bool,
332 resolve_names: bool,
333 filter: &str,
334 limit: i32,
335 provider: &str,
336 query_member_of: bool,
337 ) -> Box<dyn Future<Item = crate::models::AuthGroupsExtended, Error = Error>>;
338 fn list_auth_roles(
339 &self,
340 sort: &str,
341 resolve_names: bool,
342 limit: i32,
343 dir: &str,
344 resume: &str,
345 ) -> Box<dyn Future<Item = crate::models::AuthRolesExtended, Error = Error>>;
346 fn list_auth_users(
347 &self,
348 domain: &str,
349 zone: &str,
350 resume: &str,
351 cached: bool,
352 resolve_names: bool,
353 filter: &str,
354 limit: i32,
355 provider: &str,
356 query_member_of: bool,
357 ) -> Box<dyn Future<Item = crate::models::AuthUsersExtended, Error = Error>>;
358 fn list_providers_ads(
359 &self,
360 scope: &str,
361 ) -> Box<dyn Future<Item = crate::models::ProvidersAdsExtended, Error = Error>>;
362 fn list_providers_file(
363 &self,
364 scope: &str,
365 ) -> Box<dyn Future<Item = crate::models::ProvidersFile, Error = Error>>;
366 fn list_providers_krb5(
367 &self,
368 scope: &str,
369 ) -> Box<dyn Future<Item = crate::models::ProvidersKrb5Extended, Error = Error>>;
370 fn list_providers_ldap(
371 &self,
372 scope: &str,
373 ) -> Box<dyn Future<Item = crate::models::ProvidersLdap, Error = Error>>;
374 fn list_providers_nis(
375 &self,
376 scope: &str,
377 ) -> Box<dyn Future<Item = crate::models::ProvidersNisExtended, Error = Error>>;
378 fn list_settings_krb5_domains(
379 &self,
380 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Domains, Error = Error>>;
381 fn list_settings_krb5_realms(
382 &self,
383 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Realms, Error = Error>>;
384 fn update_auth_group(
385 &self,
386 auth_group: crate::models::AuthGroup,
387 auth_group_id: &str,
388 force: bool,
389 zone: &str,
390 provider: &str,
391 ) -> Box<dyn Future<Item = (), Error = Error>>;
392 fn update_auth_log_level(
393 &self,
394 auth_log_level: crate::models::AuthLogLevelExtended,
395 ) -> Box<dyn Future<Item = (), Error = Error>>;
396 fn update_auth_role(
397 &self,
398 auth_role: crate::models::AuthRole,
399 auth_role_id: &str,
400 ) -> Box<dyn Future<Item = (), Error = Error>>;
401 fn update_auth_user(
402 &self,
403 auth_user: crate::models::AuthUser,
404 auth_user_id: &str,
405 force: bool,
406 zone: &str,
407 provider: &str,
408 ) -> Box<dyn Future<Item = (), Error = Error>>;
409 fn update_mapping_import(
410 &self,
411 mapping_import: crate::models::MappingImport,
412 zone: &str,
413 replace: bool,
414 ) -> Box<dyn Future<Item = (), Error = Error>>;
415 fn update_mapping_users_rules(
416 &self,
417 mapping_users_rules: crate::models::MappingUsersRulesExtended,
418 zone: &str,
419 ) -> Box<dyn Future<Item = (), Error = Error>>;
420 fn update_providers_ads_by_id(
421 &self,
422 providers_ads_id_params: crate::models::ProvidersAdsIdParams,
423 providers_ads_id: &str,
424 ) -> Box<dyn Future<Item = (), Error = Error>>;
425 fn update_providers_file_by_id(
426 &self,
427 providers_file_id_params: crate::models::ProvidersFileIdParams,
428 providers_file_id: &str,
429 ) -> Box<dyn Future<Item = (), Error = Error>>;
430 fn update_providers_krb5_by_id(
431 &self,
432 providers_krb5_id_params: crate::models::ProvidersKrb5IdParams,
433 providers_krb5_id: &str,
434 ) -> Box<dyn Future<Item = (), Error = Error>>;
435 fn update_providers_ldap_by_id(
436 &self,
437 providers_ldap_id_params: crate::models::ProvidersLdapIdParams,
438 providers_ldap_id: &str,
439 force: bool,
440 ) -> Box<dyn Future<Item = (), Error = Error>>;
441 fn update_providers_local_by_id(
442 &self,
443 providers_local_id_params: crate::models::ProvidersLocalIdParams,
444 providers_local_id: &str,
445 ) -> Box<dyn Future<Item = (), Error = Error>>;
446 fn update_providers_nis_by_id(
447 &self,
448 providers_nis_id_params: crate::models::ProvidersNisIdParams,
449 providers_nis_id: &str,
450 ) -> Box<dyn Future<Item = (), Error = Error>>;
451 fn update_settings_acls(
452 &self,
453 settings_acls: crate::models::SettingsAclsExtended,
454 ) -> Box<dyn Future<Item = (), Error = Error>>;
455 fn update_settings_global(
456 &self,
457 settings_global: crate::models::SettingsGlobalGlobalSettings,
458 zone: &str,
459 ) -> Box<dyn Future<Item = (), Error = Error>>;
460 fn update_settings_krb5_defaults(
461 &self,
462 settings_krb5_defaults: crate::models::SettingsKrb5DefaultsKrb5Settings,
463 ) -> Box<dyn Future<Item = (), Error = Error>>;
464 fn update_settings_krb5_domain(
465 &self,
466 settings_krb5_domain: crate::models::SettingsKrb5Domain,
467 settings_krb5_domain_id: &str,
468 ) -> Box<dyn Future<Item = (), Error = Error>>;
469 fn update_settings_krb5_realm(
470 &self,
471 settings_krb5_realm: crate::models::SettingsKrb5Realm,
472 settings_krb5_realm_id: &str,
473 ) -> Box<dyn Future<Item = (), Error = Error>>;
474 fn update_settings_mapping(
475 &self,
476 settings_mapping: crate::models::SettingsMappingMappingSettings,
477 zone: &str,
478 ) -> Box<dyn Future<Item = (), Error = Error>>;
479}
480
481impl<C: hyper::client::connect::Connect + 'static> AuthApi for AuthApiClient<C> {
482 fn create_auth_cache_item(
483 &self,
484 auth_cache_item: crate::models::AuthCacheItem,
485 zone: &str,
486 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
487 let q = ::url::form_urlencoded::Serializer::new(String::new())
488 .append_pair("zone", &zone.to_string())
489 .finish();
490 let uri_str = format!(
491 "{}/platform/4/auth/cache?{}",
492 self.configuration.base_path, q
493 );
494 query(
495 self.configuration.borrow(),
496 &uri_str,
497 &auth_cache_item,
498 hyper::Method::POST,
499 )
500 }
501
502 fn create_auth_group(
503 &self,
504 auth_group: crate::models::AuthGroupCreateParams,
505 force: bool,
506 zone: &str,
507 provider: &str,
508 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
509 let q = ::url::form_urlencoded::Serializer::new(String::new())
510 .append_pair("force", &force.to_string())
511 .append_pair("zone", &zone.to_string())
512 .append_pair("provider", &provider.to_string())
513 .finish();
514 let uri_str = format!(
515 "{}/platform/1/auth/groups?{}",
516 self.configuration.base_path, q
517 );
518 query(
519 self.configuration.borrow(),
520 &uri_str,
521 &auth_group,
522 hyper::Method::POST,
523 )
524 }
525
526 fn create_auth_refresh_item(
527 &self,
528 auth_refresh_item: crate::models::Empty,
529 ) -> Box<dyn Future<Item = crate::models::CreateAuthRefreshItemResponse, Error = Error>> {
530 let uri_str = format!("{}/platform/3/auth/refresh", self.configuration.base_path);
531 query(
532 self.configuration.borrow(),
533 &uri_str,
534 &auth_refresh_item,
535 hyper::Method::POST,
536 )
537 }
538
539 fn create_auth_role(
540 &self,
541 auth_role: crate::models::AuthRoleCreateParams,
542 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
543 let uri_str = format!("{}/platform/1/auth/roles", self.configuration.base_path);
544 query(
545 self.configuration.borrow(),
546 &uri_str,
547 &auth_role,
548 hyper::Method::POST,
549 )
550 }
551
552 fn create_auth_user(
553 &self,
554 auth_user: crate::models::AuthUserCreateParams,
555 force: bool,
556 zone: &str,
557 provider: &str,
558 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
559 let q = ::url::form_urlencoded::Serializer::new(String::new())
560 .append_pair("force", &force.to_string())
561 .append_pair("zone", &zone.to_string())
562 .append_pair("provider", &provider.to_string())
563 .finish();
564 let uri_str = format!(
565 "{}/platform/1/auth/users?{}",
566 self.configuration.base_path, q
567 );
568 query(
569 self.configuration.borrow(),
570 &uri_str,
571 &auth_user,
572 hyper::Method::POST,
573 )
574 }
575
576 fn create_mapping_identity(
577 &self,
578 mapping_identity: crate::models::MappingIdentityCreateParams,
579 var_2way: bool,
580 zone: &str,
581 replace: bool,
582 ) -> Box<dyn Future<Item = crate::models::Empty, Error = Error>> {
583 let q = ::url::form_urlencoded::Serializer::new(String::new())
584 .append_pair("2way", &var_2way.to_string())
585 .append_pair("zone", &zone.to_string())
586 .append_pair("replace", &replace.to_string())
587 .finish();
588 let uri_str = format!(
589 "{}/platform/1/auth/mapping/identities?{}",
590 self.configuration.base_path, q
591 );
592 query(
593 self.configuration.borrow(),
594 &uri_str,
595 &mapping_identity,
596 hyper::Method::POST,
597 )
598 }
599
600 fn create_mapping_identity_0(
601 &self,
602 mapping_identity: crate::models::Empty,
603 mapping_identity_id: &str,
604 _type: &str,
605 zone: &str,
606 ) -> Box<dyn Future<Item = crate::models::MappingIdentities, Error = Error>> {
607 let q = ::url::form_urlencoded::Serializer::new(String::new())
608 .append_pair("type", &_type.to_string())
609 .append_pair("zone", &zone.to_string())
610 .finish();
611 let uri_str = format!(
612 "{}/platform/1/auth/mapping/identities/{MappingIdentityId}?{}",
613 self.configuration.base_path,
614 q,
615 MappingIdentityId = mapping_identity_id
616 );
617 query(
618 self.configuration.borrow(),
619 &uri_str,
620 &mapping_identity,
621 hyper::Method::POST,
622 )
623 }
624
625 fn create_providers_ads_item(
626 &self,
627 providers_ads_item: crate::models::ProvidersAdsItem,
628 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
629 let uri_str = format!(
630 "{}/platform/3/auth/providers/ads",
631 self.configuration.base_path
632 );
633 query(
634 self.configuration.borrow(),
635 &uri_str,
636 &providers_ads_item,
637 hyper::Method::POST,
638 )
639 }
640
641 fn create_providers_file_item(
642 &self,
643 providers_file_item: crate::models::ProvidersFileItem,
644 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
645 let uri_str = format!(
646 "{}/platform/1/auth/providers/file",
647 self.configuration.base_path
648 );
649 query(
650 self.configuration.borrow(),
651 &uri_str,
652 &providers_file_item,
653 hyper::Method::POST,
654 )
655 }
656
657 fn create_providers_krb5_item(
658 &self,
659 providers_krb5_item: crate::models::ProvidersKrb5Item,
660 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
661 let uri_str = format!(
662 "{}/platform/3/auth/providers/krb5",
663 self.configuration.base_path
664 );
665 query(
666 self.configuration.borrow(),
667 &uri_str,
668 &providers_krb5_item,
669 hyper::Method::POST,
670 )
671 }
672
673 fn create_providers_ldap_item(
674 &self,
675 providers_ldap_item: crate::models::ProvidersLdapItem,
676 force: bool,
677 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
678 let q = ::url::form_urlencoded::Serializer::new(String::new())
679 .append_pair("force", &force.to_string())
680 .finish();
681 let uri_str = format!(
682 "{}/platform/4/auth/providers/ldap?{}",
683 self.configuration.base_path, q
684 );
685 query(
686 self.configuration.borrow(),
687 &uri_str,
688 &providers_ldap_item,
689 hyper::Method::POST,
690 )
691 }
692
693 fn create_providers_nis_item(
694 &self,
695 providers_nis_item: crate::models::ProvidersNisItem,
696 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
697 let uri_str = format!(
698 "{}/platform/3/auth/providers/nis",
699 self.configuration.base_path
700 );
701 query(
702 self.configuration.borrow(),
703 &uri_str,
704 &providers_nis_item,
705 hyper::Method::POST,
706 )
707 }
708
709 fn create_settings_krb5_domain(
710 &self,
711 settings_krb5_domain: crate::models::SettingsKrb5DomainCreateParams,
712 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
713 let uri_str = format!(
714 "{}/platform/1/auth/settings/krb5/domains",
715 self.configuration.base_path
716 );
717 query(
718 self.configuration.borrow(),
719 &uri_str,
720 &settings_krb5_domain,
721 hyper::Method::POST,
722 )
723 }
724
725 fn create_settings_krb5_realm(
726 &self,
727 settings_krb5_realm: crate::models::SettingsKrb5RealmCreateParams,
728 ) -> Box<dyn Future<Item = crate::models::CreateResponse, Error = Error>> {
729 let uri_str = format!(
730 "{}/platform/1/auth/settings/krb5/realms",
731 self.configuration.base_path
732 );
733 query(
734 self.configuration.borrow(),
735 &uri_str,
736 &settings_krb5_realm,
737 hyper::Method::POST,
738 )
739 }
740
741 fn delete_auth_group(
742 &self,
743 auth_group_id: &str,
744 cached: bool,
745 zone: &str,
746 provider: &str,
747 ) -> Box<dyn Future<Item = (), Error = Error>> {
748 let q = ::url::form_urlencoded::Serializer::new(String::new())
749 .append_pair("cached", &cached.to_string())
750 .append_pair("zone", &zone.to_string())
751 .append_pair("provider", &provider.to_string())
752 .finish();
753 let uri_str = format!(
754 "{}/platform/1/auth/groups/{AuthGroupId}?{}",
755 self.configuration.base_path,
756 q,
757 AuthGroupId = auth_group_id
758 );
759 query(
760 self.configuration.borrow(),
761 &uri_str,
762 &"",
763 hyper::Method::DELETE,
764 )
765 }
766
767 fn delete_auth_groups(
768 &self,
769 cached: bool,
770 zone: &str,
771 provider: &str,
772 ) -> Box<dyn Future<Item = (), Error = Error>> {
773 let q = ::url::form_urlencoded::Serializer::new(String::new())
774 .append_pair("cached", &cached.to_string())
775 .append_pair("zone", &zone.to_string())
776 .append_pair("provider", &provider.to_string())
777 .finish();
778 let uri_str = format!(
779 "{}/platform/1/auth/groups?{}",
780 self.configuration.base_path, q
781 );
782 query(
783 self.configuration.borrow(),
784 &uri_str,
785 &"",
786 hyper::Method::DELETE,
787 )
788 }
789
790 fn delete_auth_role(&self, auth_role_id: &str) -> Box<dyn Future<Item = (), Error = Error>> {
791 let uri_str = format!(
792 "{}/platform/1/auth/roles/{AuthRoleId}",
793 self.configuration.base_path,
794 AuthRoleId = auth_role_id
795 );
796 query(
797 self.configuration.borrow(),
798 &uri_str,
799 &"",
800 hyper::Method::DELETE,
801 )
802 }
803
804 fn delete_auth_user(
805 &self,
806 auth_user_id: &str,
807 cached: bool,
808 zone: &str,
809 provider: &str,
810 ) -> Box<dyn Future<Item = (), Error = Error>> {
811 let q = ::url::form_urlencoded::Serializer::new(String::new())
812 .append_pair("cached", &cached.to_string())
813 .append_pair("zone", &zone.to_string())
814 .append_pair("provider", &provider.to_string())
815 .finish();
816 let uri_str = format!(
817 "{}/platform/1/auth/users/{AuthUserId}?{}",
818 self.configuration.base_path,
819 q,
820 AuthUserId = auth_user_id
821 );
822 query(
823 self.configuration.borrow(),
824 &uri_str,
825 &"",
826 hyper::Method::DELETE,
827 )
828 }
829
830 fn delete_auth_users(
831 &self,
832 cached: bool,
833 zone: &str,
834 provider: &str,
835 ) -> Box<dyn Future<Item = (), Error = Error>> {
836 let q = ::url::form_urlencoded::Serializer::new(String::new())
837 .append_pair("cached", &cached.to_string())
838 .append_pair("zone", &zone.to_string())
839 .append_pair("provider", &provider.to_string())
840 .finish();
841 let uri_str = format!(
842 "{}/platform/1/auth/users?{}",
843 self.configuration.base_path, q
844 );
845 query(
846 self.configuration.borrow(),
847 &uri_str,
848 &"",
849 hyper::Method::DELETE,
850 )
851 }
852
853 fn delete_mapping_identities(
854 &self,
855 filter: &str,
856 zone: &str,
857 remove: bool,
858 ) -> Box<dyn Future<Item = (), Error = Error>> {
859 let q = ::url::form_urlencoded::Serializer::new(String::new())
860 .append_pair("filter", &filter.to_string())
861 .append_pair("zone", &zone.to_string())
862 .append_pair("remove", &remove.to_string())
863 .finish();
864 let uri_str = format!(
865 "{}/platform/1/auth/mapping/identities?{}",
866 self.configuration.base_path, q
867 );
868 query(
869 self.configuration.borrow(),
870 &uri_str,
871 &"",
872 hyper::Method::DELETE,
873 )
874 }
875
876 fn delete_mapping_identity(
877 &self,
878 mapping_identity_id: &str,
879 zone: &str,
880 var_2way: bool,
881 target: &str,
882 remove: bool,
883 ) -> Box<dyn Future<Item = (), Error = Error>> {
884 let q = ::url::form_urlencoded::Serializer::new(String::new())
885 .append_pair("zone", &zone.to_string())
886 .append_pair("2way", &var_2way.to_string())
887 .append_pair("target", &target.to_string())
888 .append_pair("remove", &remove.to_string())
889 .finish();
890 let uri_str = format!(
891 "{}/platform/1/auth/mapping/identities/{MappingIdentityId}?{}",
892 self.configuration.base_path,
893 q,
894 MappingIdentityId = mapping_identity_id
895 );
896 query(
897 self.configuration.borrow(),
898 &uri_str,
899 &"",
900 hyper::Method::DELETE,
901 )
902 }
903
904 fn delete_providers_ads_by_id(
905 &self,
906 providers_ads_id: &str,
907 ) -> Box<dyn Future<Item = (), Error = Error>> {
908 let uri_str = format!(
909 "{}/platform/3/auth/providers/ads/{ProvidersAdsId}",
910 self.configuration.base_path,
911 ProvidersAdsId = providers_ads_id
912 );
913 query(
914 self.configuration.borrow(),
915 &uri_str,
916 &"",
917 hyper::Method::DELETE,
918 )
919 }
920
921 fn delete_providers_file_by_id(
922 &self,
923 providers_file_id: &str,
924 ) -> Box<dyn Future<Item = (), Error = Error>> {
925 let uri_str = format!(
926 "{}/platform/1/auth/providers/file/{ProvidersFileId}",
927 self.configuration.base_path,
928 ProvidersFileId = providers_file_id
929 );
930 query(
931 self.configuration.borrow(),
932 &uri_str,
933 &"",
934 hyper::Method::DELETE,
935 )
936 }
937
938 fn delete_providers_krb5_by_id(
939 &self,
940 providers_krb5_id: &str,
941 ) -> Box<dyn Future<Item = (), Error = Error>> {
942 let uri_str = format!(
943 "{}/platform/3/auth/providers/krb5/{ProvidersKrb5Id}",
944 self.configuration.base_path,
945 ProvidersKrb5Id = providers_krb5_id
946 );
947 query(
948 self.configuration.borrow(),
949 &uri_str,
950 &"",
951 hyper::Method::DELETE,
952 )
953 }
954
955 fn delete_providers_ldap_by_id(
956 &self,
957 providers_ldap_id: &str,
958 ) -> Box<dyn Future<Item = (), Error = Error>> {
959 let uri_str = format!(
960 "{}/platform/4/auth/providers/ldap/{ProvidersLdapId}",
961 self.configuration.base_path,
962 ProvidersLdapId = providers_ldap_id
963 );
964 query(
965 self.configuration.borrow(),
966 &uri_str,
967 &"",
968 hyper::Method::DELETE,
969 )
970 }
971
972 fn delete_providers_local_by_id(
973 &self,
974 providers_local_id: &str,
975 ) -> Box<dyn Future<Item = (), Error = Error>> {
976 let uri_str = format!(
977 "{}/platform/1/auth/providers/local/{ProvidersLocalId}",
978 self.configuration.base_path,
979 ProvidersLocalId = providers_local_id
980 );
981 query(
982 self.configuration.borrow(),
983 &uri_str,
984 &"",
985 hyper::Method::DELETE,
986 )
987 }
988
989 fn delete_providers_nis_by_id(
990 &self,
991 providers_nis_id: &str,
992 ) -> Box<dyn Future<Item = (), Error = Error>> {
993 let uri_str = format!(
994 "{}/platform/3/auth/providers/nis/{ProvidersNisId}",
995 self.configuration.base_path,
996 ProvidersNisId = providers_nis_id
997 );
998 query(
999 self.configuration.borrow(),
1000 &uri_str,
1001 &"",
1002 hyper::Method::DELETE,
1003 )
1004 }
1005
1006 fn delete_settings_krb5_domain(
1007 &self,
1008 settings_krb5_domain_id: &str,
1009 ) -> Box<dyn Future<Item = (), Error = Error>> {
1010 let uri_str = format!(
1011 "{}/platform/1/auth/settings/krb5/domains/{SettingsKrb5DomainId}",
1012 self.configuration.base_path,
1013 SettingsKrb5DomainId = settings_krb5_domain_id
1014 );
1015 query(
1016 self.configuration.borrow(),
1017 &uri_str,
1018 &"",
1019 hyper::Method::DELETE,
1020 )
1021 }
1022
1023 fn delete_settings_krb5_realm(
1024 &self,
1025 settings_krb5_realm_id: &str,
1026 ) -> Box<dyn Future<Item = (), Error = Error>> {
1027 let uri_str = format!(
1028 "{}/platform/1/auth/settings/krb5/realms/{SettingsKrb5RealmId}",
1029 self.configuration.base_path,
1030 SettingsKrb5RealmId = settings_krb5_realm_id
1031 );
1032 query(
1033 self.configuration.borrow(),
1034 &uri_str,
1035 &"",
1036 hyper::Method::DELETE,
1037 )
1038 }
1039
1040 fn get_auth_access_user(
1041 &self,
1042 auth_access_user: &str,
1043 path: &str,
1044 share: &str,
1045 zone: &str,
1046 numeric: bool,
1047 ) -> Box<dyn Future<Item = crate::models::AuthAccess, Error = Error>> {
1048 let q = ::url::form_urlencoded::Serializer::new(String::new())
1049 .append_pair("path", &path.to_string())
1050 .append_pair("share", &share.to_string())
1051 .append_pair("zone", &zone.to_string())
1052 .append_pair("numeric", &numeric.to_string())
1053 .finish();
1054 let uri_str = format!(
1055 "{}/platform/1/auth/access/{AuthAccessUser}?{}",
1056 self.configuration.base_path,
1057 q,
1058 AuthAccessUser = auth_access_user
1059 );
1060 query(
1061 self.configuration.borrow(),
1062 &uri_str,
1063 &"",
1064 hyper::Method::GET,
1065 )
1066 }
1067
1068 fn get_auth_group(
1069 &self,
1070 auth_group_id: &str,
1071 cached: bool,
1072 resolve_names: bool,
1073 query_member_of: bool,
1074 zone: &str,
1075 provider: &str,
1076 ) -> Box<dyn Future<Item = crate::models::AuthGroups, Error = Error>> {
1077 let q = ::url::form_urlencoded::Serializer::new(String::new())
1078 .append_pair("cached", &cached.to_string())
1079 .append_pair("resolve_names", &resolve_names.to_string())
1080 .append_pair("query_member_of", &query_member_of.to_string())
1081 .append_pair("zone", &zone.to_string())
1082 .append_pair("provider", &provider.to_string())
1083 .finish();
1084 let uri_str = format!(
1085 "{}/platform/1/auth/groups/{AuthGroupId}?{}",
1086 self.configuration.base_path,
1087 q,
1088 AuthGroupId = auth_group_id
1089 );
1090 query(
1091 self.configuration.borrow(),
1092 &uri_str,
1093 &"",
1094 hyper::Method::GET,
1095 )
1096 }
1097
1098 fn get_auth_id(&self) -> Box<dyn Future<Item = crate::models::AuthId, Error = Error>> {
1099 let uri_str = format!("{}/platform/1/auth/id", self.configuration.base_path);
1100 query(
1101 self.configuration.borrow(),
1102 &uri_str,
1103 &"",
1104 hyper::Method::GET,
1105 )
1106 }
1107
1108 fn get_auth_ldap_template(
1109 &self,
1110 auth_ldap_template_id: &str,
1111 ) -> Box<dyn Future<Item = crate::models::AuthLdapTemplates, Error = Error>> {
1112 let uri_str = format!(
1113 "{}/platform/4/auth/ldap-templates/{AuthLdapTemplateId}",
1114 self.configuration.base_path,
1115 AuthLdapTemplateId = auth_ldap_template_id
1116 );
1117 query(
1118 self.configuration.borrow(),
1119 &uri_str,
1120 &"",
1121 hyper::Method::GET,
1122 )
1123 }
1124
1125 fn get_auth_ldap_templates(
1126 &self,
1127 ) -> Box<dyn Future<Item = crate::models::AuthLdapTemplatesExtended, Error = Error>> {
1128 let uri_str = format!(
1129 "{}/platform/4/auth/ldap-templates",
1130 self.configuration.base_path
1131 );
1132 query(
1133 self.configuration.borrow(),
1134 &uri_str,
1135 &"",
1136 hyper::Method::GET,
1137 )
1138 }
1139
1140 fn get_auth_log_level(
1141 &self,
1142 ) -> Box<dyn Future<Item = crate::models::AuthLogLevel, Error = Error>> {
1143 let uri_str = format!("{}/platform/3/auth/log-level", self.configuration.base_path);
1144 query(
1145 self.configuration.borrow(),
1146 &uri_str,
1147 &"",
1148 hyper::Method::GET,
1149 )
1150 }
1151
1152 fn get_auth_netgroup(
1153 &self,
1154 auth_netgroup_id: &str,
1155 ignore_errors: bool,
1156 recursive: bool,
1157 zone: &str,
1158 provider: &str,
1159 ) -> Box<dyn Future<Item = crate::models::AuthNetgroups, Error = Error>> {
1160 let q = ::url::form_urlencoded::Serializer::new(String::new())
1161 .append_pair("ignore_errors", &ignore_errors.to_string())
1162 .append_pair("recursive", &recursive.to_string())
1163 .append_pair("zone", &zone.to_string())
1164 .append_pair("provider", &provider.to_string())
1165 .finish();
1166 let uri_str = format!(
1167 "{}/platform/1/auth/netgroups/{AuthNetgroupId}?{}",
1168 self.configuration.base_path,
1169 q,
1170 AuthNetgroupId = auth_netgroup_id
1171 );
1172 query(
1173 self.configuration.borrow(),
1174 &uri_str,
1175 &"",
1176 hyper::Method::GET,
1177 )
1178 }
1179
1180 fn get_auth_privileges(
1181 &self,
1182 ) -> Box<dyn Future<Item = crate::models::AuthPrivileges, Error = Error>> {
1183 let uri_str = format!(
1184 "{}/platform/1/auth/privileges",
1185 self.configuration.base_path
1186 );
1187 query(
1188 self.configuration.borrow(),
1189 &uri_str,
1190 &"",
1191 hyper::Method::GET,
1192 )
1193 }
1194
1195 fn get_auth_role(
1196 &self,
1197 auth_role_id: &str,
1198 resolve_names: bool,
1199 ) -> Box<dyn Future<Item = crate::models::AuthRoles, Error = Error>> {
1200 let q = ::url::form_urlencoded::Serializer::new(String::new())
1201 .append_pair("resolve_names", &resolve_names.to_string())
1202 .finish();
1203 let uri_str = format!(
1204 "{}/platform/1/auth/roles/{AuthRoleId}?{}",
1205 self.configuration.base_path,
1206 q,
1207 AuthRoleId = auth_role_id
1208 );
1209 query(
1210 self.configuration.borrow(),
1211 &uri_str,
1212 &"",
1213 hyper::Method::GET,
1214 )
1215 }
1216
1217 fn get_auth_shells(&self) -> Box<dyn Future<Item = crate::models::AuthShells, Error = Error>> {
1218 let uri_str = format!("{}/platform/1/auth/shells", self.configuration.base_path);
1219 query(
1220 self.configuration.borrow(),
1221 &uri_str,
1222 &"",
1223 hyper::Method::GET,
1224 )
1225 }
1226
1227 fn get_auth_user(
1228 &self,
1229 auth_user_id: &str,
1230 cached: bool,
1231 resolve_names: bool,
1232 query_member_of: bool,
1233 zone: &str,
1234 provider: &str,
1235 ) -> Box<dyn Future<Item = crate::models::AuthUsers, Error = Error>> {
1236 let q = ::url::form_urlencoded::Serializer::new(String::new())
1237 .append_pair("cached", &cached.to_string())
1238 .append_pair("resolve_names", &resolve_names.to_string())
1239 .append_pair("query_member_of", &query_member_of.to_string())
1240 .append_pair("zone", &zone.to_string())
1241 .append_pair("provider", &provider.to_string())
1242 .finish();
1243 let uri_str = format!(
1244 "{}/platform/1/auth/users/{AuthUserId}?{}",
1245 self.configuration.base_path,
1246 q,
1247 AuthUserId = auth_user_id
1248 );
1249 query(
1250 self.configuration.borrow(),
1251 &uri_str,
1252 &"",
1253 hyper::Method::GET,
1254 )
1255 }
1256
1257 fn get_auth_wellknown(
1258 &self,
1259 auth_wellknown_id: &str,
1260 scope: &str,
1261 ) -> Box<dyn Future<Item = crate::models::AuthWellknowns, Error = Error>> {
1262 let q = ::url::form_urlencoded::Serializer::new(String::new())
1263 .append_pair("scope", &scope.to_string())
1264 .finish();
1265 let uri_str = format!(
1266 "{}/platform/1/auth/wellknowns/{AuthWellknownId}?{}",
1267 self.configuration.base_path,
1268 q,
1269 AuthWellknownId = auth_wellknown_id
1270 );
1271 query(
1272 self.configuration.borrow(),
1273 &uri_str,
1274 &"",
1275 hyper::Method::GET,
1276 )
1277 }
1278
1279 fn get_auth_wellknowns(
1280 &self,
1281 ) -> Box<dyn Future<Item = crate::models::AuthWellknowns, Error = Error>> {
1282 let uri_str = format!(
1283 "{}/platform/1/auth/wellknowns",
1284 self.configuration.base_path
1285 );
1286 query(
1287 self.configuration.borrow(),
1288 &uri_str,
1289 &"",
1290 hyper::Method::GET,
1291 )
1292 }
1293
1294 fn get_mapping_dump(
1295 &self,
1296 nocreate: bool,
1297 zone: &str,
1298 ) -> Box<dyn Future<Item = crate::models::MappingDump, Error = Error>> {
1299 let q = ::url::form_urlencoded::Serializer::new(String::new())
1300 .append_pair("nocreate", &nocreate.to_string())
1301 .append_pair("zone", &zone.to_string())
1302 .finish();
1303 let uri_str = format!(
1304 "{}/platform/3/auth/mapping/dump?{}",
1305 self.configuration.base_path, q
1306 );
1307 query(
1308 self.configuration.borrow(),
1309 &uri_str,
1310 &"",
1311 hyper::Method::GET,
1312 )
1313 }
1314
1315 fn get_mapping_identity(
1316 &self,
1317 mapping_identity_id: &str,
1318 nocreate: bool,
1319 zone: &str,
1320 ) -> Box<dyn Future<Item = crate::models::MappingIdentities, Error = Error>> {
1321 let q = ::url::form_urlencoded::Serializer::new(String::new())
1322 .append_pair("nocreate", &nocreate.to_string())
1323 .append_pair("zone", &zone.to_string())
1324 .finish();
1325 let uri_str = format!(
1326 "{}/platform/1/auth/mapping/identities/{MappingIdentityId}?{}",
1327 self.configuration.base_path,
1328 q,
1329 MappingIdentityId = mapping_identity_id
1330 );
1331 query(
1332 self.configuration.borrow(),
1333 &uri_str,
1334 &"",
1335 hyper::Method::GET,
1336 )
1337 }
1338
1339 fn get_mapping_users_lookup(
1340 &self,
1341 primary_gid: i32,
1342 uid: i32,
1343 zone: &str,
1344 gid: Vec<i32>,
1345 user: &str,
1346 kerberos_principal: &str,
1347 ) -> Box<dyn Future<Item = crate::models::MappingUsersLookup, Error = Error>> {
1348 let q = ::url::form_urlencoded::Serializer::new(String::new())
1349 .append_pair("primary_gid", &primary_gid.to_string())
1350 .append_pair("uid", &uid.to_string())
1351 .append_pair("zone", &zone.to_string())
1352 .append_pair(
1353 "gid",
1354 &gid.iter()
1355 .map(|i| i.to_string())
1356 .collect::<Vec<String>>()
1357 .join(",")
1358 .to_string(),
1359 )
1360 .append_pair("user", &user.to_string())
1361 .append_pair("kerberos_principal", &kerberos_principal.to_string())
1362 .finish();
1363 let uri_str = format!(
1364 "{}/platform/1/auth/mapping/users/lookup?{}",
1365 self.configuration.base_path, q
1366 );
1367 query(
1368 self.configuration.borrow(),
1369 &uri_str,
1370 &"",
1371 hyper::Method::GET,
1372 )
1373 }
1374
1375 fn get_mapping_users_rules(
1376 &self,
1377 zone: &str,
1378 ) -> Box<dyn Future<Item = crate::models::MappingUsersRules, Error = Error>> {
1379 let q = ::url::form_urlencoded::Serializer::new(String::new())
1380 .append_pair("zone", &zone.to_string())
1381 .finish();
1382 let uri_str = format!(
1383 "{}/platform/1/auth/mapping/users/rules?{}",
1384 self.configuration.base_path, q
1385 );
1386 query(
1387 self.configuration.borrow(),
1388 &uri_str,
1389 &"",
1390 hyper::Method::GET,
1391 )
1392 }
1393
1394 fn get_providers_ads_by_id(
1395 &self,
1396 providers_ads_id: &str,
1397 scope: &str,
1398 ) -> Box<dyn Future<Item = crate::models::ProvidersAds, Error = Error>> {
1399 let q = ::url::form_urlencoded::Serializer::new(String::new())
1400 .append_pair("scope", &scope.to_string())
1401 .finish();
1402 let uri_str = format!(
1403 "{}/platform/3/auth/providers/ads/{ProvidersAdsId}?{}",
1404 self.configuration.base_path,
1405 q,
1406 ProvidersAdsId = providers_ads_id
1407 );
1408 query(
1409 self.configuration.borrow(),
1410 &uri_str,
1411 &"",
1412 hyper::Method::GET,
1413 )
1414 }
1415
1416 fn get_providers_file_by_id(
1417 &self,
1418 providers_file_id: &str,
1419 scope: &str,
1420 ) -> Box<dyn Future<Item = crate::models::ProvidersFile, Error = Error>> {
1421 let q = ::url::form_urlencoded::Serializer::new(String::new())
1422 .append_pair("scope", &scope.to_string())
1423 .finish();
1424 let uri_str = format!(
1425 "{}/platform/1/auth/providers/file/{ProvidersFileId}?{}",
1426 self.configuration.base_path,
1427 q,
1428 ProvidersFileId = providers_file_id
1429 );
1430 query(
1431 self.configuration.borrow(),
1432 &uri_str,
1433 &"",
1434 hyper::Method::GET,
1435 )
1436 }
1437
1438 fn get_providers_krb5_by_id(
1439 &self,
1440 providers_krb5_id: &str,
1441 scope: &str,
1442 ) -> Box<dyn Future<Item = crate::models::ProvidersKrb5, Error = Error>> {
1443 let q = ::url::form_urlencoded::Serializer::new(String::new())
1444 .append_pair("scope", &scope.to_string())
1445 .finish();
1446 let uri_str = format!(
1447 "{}/platform/3/auth/providers/krb5/{ProvidersKrb5Id}?{}",
1448 self.configuration.base_path,
1449 q,
1450 ProvidersKrb5Id = providers_krb5_id
1451 );
1452 query(
1453 self.configuration.borrow(),
1454 &uri_str,
1455 &"",
1456 hyper::Method::GET,
1457 )
1458 }
1459
1460 fn get_providers_ldap_by_id(
1461 &self,
1462 providers_ldap_id: &str,
1463 scope: &str,
1464 ) -> Box<dyn Future<Item = crate::models::ProvidersLdap, Error = Error>> {
1465 let q = ::url::form_urlencoded::Serializer::new(String::new())
1466 .append_pair("scope", &scope.to_string())
1467 .finish();
1468 let uri_str = format!(
1469 "{}/platform/4/auth/providers/ldap/{ProvidersLdapId}?{}",
1470 self.configuration.base_path,
1471 q,
1472 ProvidersLdapId = providers_ldap_id
1473 );
1474 query(
1475 self.configuration.borrow(),
1476 &uri_str,
1477 &"",
1478 hyper::Method::GET,
1479 )
1480 }
1481
1482 fn get_providers_local(
1483 &self,
1484 scope: &str,
1485 ) -> Box<dyn Future<Item = crate::models::ProvidersLocal, Error = Error>> {
1486 let q = ::url::form_urlencoded::Serializer::new(String::new())
1487 .append_pair("scope", &scope.to_string())
1488 .finish();
1489 let uri_str = format!(
1490 "{}/platform/1/auth/providers/local?{}",
1491 self.configuration.base_path, q
1492 );
1493 query(
1494 self.configuration.borrow(),
1495 &uri_str,
1496 &"",
1497 hyper::Method::GET,
1498 )
1499 }
1500
1501 fn get_providers_local_by_id(
1502 &self,
1503 providers_local_id: &str,
1504 scope: &str,
1505 ) -> Box<dyn Future<Item = crate::models::ProvidersLocal, Error = Error>> {
1506 let q = ::url::form_urlencoded::Serializer::new(String::new())
1507 .append_pair("scope", &scope.to_string())
1508 .finish();
1509 let uri_str = format!(
1510 "{}/platform/1/auth/providers/local/{ProvidersLocalId}?{}",
1511 self.configuration.base_path,
1512 q,
1513 ProvidersLocalId = providers_local_id
1514 );
1515 query(
1516 self.configuration.borrow(),
1517 &uri_str,
1518 &"",
1519 hyper::Method::GET,
1520 )
1521 }
1522
1523 fn get_providers_nis_by_id(
1524 &self,
1525 providers_nis_id: &str,
1526 scope: &str,
1527 ) -> Box<dyn Future<Item = crate::models::ProvidersNis, Error = Error>> {
1528 let q = ::url::form_urlencoded::Serializer::new(String::new())
1529 .append_pair("scope", &scope.to_string())
1530 .finish();
1531 let uri_str = format!(
1532 "{}/platform/3/auth/providers/nis/{ProvidersNisId}?{}",
1533 self.configuration.base_path,
1534 q,
1535 ProvidersNisId = providers_nis_id
1536 );
1537 query(
1538 self.configuration.borrow(),
1539 &uri_str,
1540 &"",
1541 hyper::Method::GET,
1542 )
1543 }
1544
1545 fn get_providers_summary(
1546 &self,
1547 groupnet: &str,
1548 zone: &str,
1549 ) -> Box<dyn Future<Item = crate::models::ProvidersSummary, Error = Error>> {
1550 let q = ::url::form_urlencoded::Serializer::new(String::new())
1551 .append_pair("groupnet", &groupnet.to_string())
1552 .append_pair("zone", &zone.to_string())
1553 .finish();
1554 let uri_str = format!(
1555 "{}/platform/3/auth/providers/summary?{}",
1556 self.configuration.base_path, q
1557 );
1558 query(
1559 self.configuration.borrow(),
1560 &uri_str,
1561 &"",
1562 hyper::Method::GET,
1563 )
1564 }
1565
1566 fn get_settings_acls(
1567 &self,
1568 preset: &str,
1569 ) -> Box<dyn Future<Item = crate::models::SettingsAcls, Error = Error>> {
1570 let q = ::url::form_urlencoded::Serializer::new(String::new())
1571 .append_pair("preset", &preset.to_string())
1572 .finish();
1573 let uri_str = format!(
1574 "{}/platform/3/auth/settings/acls?{}",
1575 self.configuration.base_path, q
1576 );
1577 query(
1578 self.configuration.borrow(),
1579 &uri_str,
1580 &"",
1581 hyper::Method::GET,
1582 )
1583 }
1584
1585 fn get_settings_global(
1586 &self,
1587 scope: &str,
1588 zone: &str,
1589 ) -> Box<dyn Future<Item = crate::models::SettingsGlobal, Error = Error>> {
1590 let q = ::url::form_urlencoded::Serializer::new(String::new())
1591 .append_pair("scope", &scope.to_string())
1592 .append_pair("zone", &zone.to_string())
1593 .finish();
1594 let uri_str = format!(
1595 "{}/platform/1/auth/settings/global?{}",
1596 self.configuration.base_path, q
1597 );
1598 query(
1599 self.configuration.borrow(),
1600 &uri_str,
1601 &"",
1602 hyper::Method::GET,
1603 )
1604 }
1605
1606 fn get_settings_krb5_defaults(
1607 &self,
1608 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Defaults, Error = Error>> {
1609 let uri_str = format!(
1610 "{}/platform/1/auth/settings/krb5/defaults",
1611 self.configuration.base_path
1612 );
1613 query(
1614 self.configuration.borrow(),
1615 &uri_str,
1616 &"",
1617 hyper::Method::GET,
1618 )
1619 }
1620
1621 fn get_settings_krb5_domain(
1622 &self,
1623 settings_krb5_domain_id: &str,
1624 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Domains, Error = Error>> {
1625 let uri_str = format!(
1626 "{}/platform/1/auth/settings/krb5/domains/{SettingsKrb5DomainId}",
1627 self.configuration.base_path,
1628 SettingsKrb5DomainId = settings_krb5_domain_id
1629 );
1630 query(
1631 self.configuration.borrow(),
1632 &uri_str,
1633 &"",
1634 hyper::Method::GET,
1635 )
1636 }
1637
1638 fn get_settings_krb5_realm(
1639 &self,
1640 settings_krb5_realm_id: &str,
1641 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Realms, Error = Error>> {
1642 let uri_str = format!(
1643 "{}/platform/1/auth/settings/krb5/realms/{SettingsKrb5RealmId}",
1644 self.configuration.base_path,
1645 SettingsKrb5RealmId = settings_krb5_realm_id
1646 );
1647 query(
1648 self.configuration.borrow(),
1649 &uri_str,
1650 &"",
1651 hyper::Method::GET,
1652 )
1653 }
1654
1655 fn get_settings_mapping(
1656 &self,
1657 scope: &str,
1658 zone: &str,
1659 ) -> Box<dyn Future<Item = crate::models::SettingsMapping, Error = Error>> {
1660 let q = ::url::form_urlencoded::Serializer::new(String::new())
1661 .append_pair("scope", &scope.to_string())
1662 .append_pair("zone", &zone.to_string())
1663 .finish();
1664 let uri_str = format!(
1665 "{}/platform/1/auth/settings/mapping?{}",
1666 self.configuration.base_path, q
1667 );
1668 query(
1669 self.configuration.borrow(),
1670 &uri_str,
1671 &"",
1672 hyper::Method::GET,
1673 )
1674 }
1675
1676 fn list_auth_groups(
1677 &self,
1678 domain: &str,
1679 zone: &str,
1680 resume: &str,
1681 cached: bool,
1682 resolve_names: bool,
1683 filter: &str,
1684 limit: i32,
1685 provider: &str,
1686 query_member_of: bool,
1687 ) -> Box<dyn Future<Item = crate::models::AuthGroupsExtended, Error = Error>> {
1688 let q = ::url::form_urlencoded::Serializer::new(String::new())
1689 .append_pair("domain", &domain.to_string())
1690 .append_pair("zone", &zone.to_string())
1691 .append_pair("resume", &resume.to_string())
1692 .append_pair("cached", &cached.to_string())
1693 .append_pair("resolve_names", &resolve_names.to_string())
1694 .append_pair("filter", &filter.to_string())
1695 .append_pair("limit", &limit.to_string())
1696 .append_pair("provider", &provider.to_string())
1697 .append_pair("query_member_of", &query_member_of.to_string())
1698 .finish();
1699 let uri_str = format!(
1700 "{}/platform/1/auth/groups?{}",
1701 self.configuration.base_path, q
1702 );
1703 query(
1704 self.configuration.borrow(),
1705 &uri_str,
1706 &"",
1707 hyper::Method::GET,
1708 )
1709 }
1710
1711 fn list_auth_roles(
1712 &self,
1713 sort: &str,
1714 resolve_names: bool,
1715 limit: i32,
1716 dir: &str,
1717 resume: &str,
1718 ) -> Box<dyn Future<Item = crate::models::AuthRolesExtended, Error = Error>> {
1719 let q = ::url::form_urlencoded::Serializer::new(String::new())
1720 .append_pair("sort", &sort.to_string())
1721 .append_pair("resolve_names", &resolve_names.to_string())
1722 .append_pair("limit", &limit.to_string())
1723 .append_pair("dir", &dir.to_string())
1724 .append_pair("resume", &resume.to_string())
1725 .finish();
1726 let uri_str = format!(
1727 "{}/platform/1/auth/roles?{}",
1728 self.configuration.base_path, q
1729 );
1730 query(
1731 self.configuration.borrow(),
1732 &uri_str,
1733 &"",
1734 hyper::Method::GET,
1735 )
1736 }
1737
1738 fn list_auth_users(
1739 &self,
1740 domain: &str,
1741 zone: &str,
1742 resume: &str,
1743 cached: bool,
1744 resolve_names: bool,
1745 filter: &str,
1746 limit: i32,
1747 provider: &str,
1748 query_member_of: bool,
1749 ) -> Box<dyn Future<Item = crate::models::AuthUsersExtended, Error = Error>> {
1750 let q = ::url::form_urlencoded::Serializer::new(String::new())
1751 .append_pair("domain", &domain.to_string())
1752 .append_pair("zone", &zone.to_string())
1753 .append_pair("resume", &resume.to_string())
1754 .append_pair("cached", &cached.to_string())
1755 .append_pair("resolve_names", &resolve_names.to_string())
1756 .append_pair("filter", &filter.to_string())
1757 .append_pair("limit", &limit.to_string())
1758 .append_pair("provider", &provider.to_string())
1759 .append_pair("query_member_of", &query_member_of.to_string())
1760 .finish();
1761 let uri_str = format!(
1762 "{}/platform/1/auth/users?{}",
1763 self.configuration.base_path, q
1764 );
1765 query(
1766 self.configuration.borrow(),
1767 &uri_str,
1768 &"",
1769 hyper::Method::GET,
1770 )
1771 }
1772
1773 fn list_providers_ads(
1774 &self,
1775 scope: &str,
1776 ) -> Box<dyn Future<Item = crate::models::ProvidersAdsExtended, Error = Error>> {
1777 let q = ::url::form_urlencoded::Serializer::new(String::new())
1778 .append_pair("scope", &scope.to_string())
1779 .finish();
1780 let uri_str = format!(
1781 "{}/platform/3/auth/providers/ads?{}",
1782 self.configuration.base_path, q
1783 );
1784 query(
1785 self.configuration.borrow(),
1786 &uri_str,
1787 &"",
1788 hyper::Method::GET,
1789 )
1790 }
1791
1792 fn list_providers_file(
1793 &self,
1794 scope: &str,
1795 ) -> Box<dyn Future<Item = crate::models::ProvidersFile, Error = Error>> {
1796 let q = ::url::form_urlencoded::Serializer::new(String::new())
1797 .append_pair("scope", &scope.to_string())
1798 .finish();
1799 let uri_str = format!(
1800 "{}/platform/1/auth/providers/file?{}",
1801 self.configuration.base_path, q
1802 );
1803 query(
1804 self.configuration.borrow(),
1805 &uri_str,
1806 &"",
1807 hyper::Method::GET,
1808 )
1809 }
1810
1811 fn list_providers_krb5(
1812 &self,
1813 scope: &str,
1814 ) -> Box<dyn Future<Item = crate::models::ProvidersKrb5Extended, Error = Error>> {
1815 let q = ::url::form_urlencoded::Serializer::new(String::new())
1816 .append_pair("scope", &scope.to_string())
1817 .finish();
1818 let uri_str = format!(
1819 "{}/platform/3/auth/providers/krb5?{}",
1820 self.configuration.base_path, q
1821 );
1822 query(
1823 self.configuration.borrow(),
1824 &uri_str,
1825 &"",
1826 hyper::Method::GET,
1827 )
1828 }
1829
1830 fn list_providers_ldap(
1831 &self,
1832 scope: &str,
1833 ) -> Box<dyn Future<Item = crate::models::ProvidersLdap, Error = Error>> {
1834 let q = ::url::form_urlencoded::Serializer::new(String::new())
1835 .append_pair("scope", &scope.to_string())
1836 .finish();
1837 let uri_str = format!(
1838 "{}/platform/4/auth/providers/ldap?{}",
1839 self.configuration.base_path, q
1840 );
1841 query(
1842 self.configuration.borrow(),
1843 &uri_str,
1844 &"",
1845 hyper::Method::GET,
1846 )
1847 }
1848
1849 fn list_providers_nis(
1850 &self,
1851 scope: &str,
1852 ) -> Box<dyn Future<Item = crate::models::ProvidersNisExtended, Error = Error>> {
1853 let q = ::url::form_urlencoded::Serializer::new(String::new())
1854 .append_pair("scope", &scope.to_string())
1855 .finish();
1856 let uri_str = format!(
1857 "{}/platform/3/auth/providers/nis?{}",
1858 self.configuration.base_path, q
1859 );
1860 query(
1861 self.configuration.borrow(),
1862 &uri_str,
1863 &"",
1864 hyper::Method::GET,
1865 )
1866 }
1867
1868 fn list_settings_krb5_domains(
1869 &self,
1870 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Domains, Error = Error>> {
1871 let uri_str = format!(
1872 "{}/platform/1/auth/settings/krb5/domains",
1873 self.configuration.base_path
1874 );
1875 query(
1876 self.configuration.borrow(),
1877 &uri_str,
1878 &"",
1879 hyper::Method::GET,
1880 )
1881 }
1882
1883 fn list_settings_krb5_realms(
1884 &self,
1885 ) -> Box<dyn Future<Item = crate::models::SettingsKrb5Realms, Error = Error>> {
1886 let uri_str = format!(
1887 "{}/platform/1/auth/settings/krb5/realms",
1888 self.configuration.base_path
1889 );
1890 query(
1891 self.configuration.borrow(),
1892 &uri_str,
1893 &"",
1894 hyper::Method::GET,
1895 )
1896 }
1897
1898 fn update_auth_group(
1899 &self,
1900 auth_group: crate::models::AuthGroup,
1901 auth_group_id: &str,
1902 force: bool,
1903 zone: &str,
1904 provider: &str,
1905 ) -> Box<dyn Future<Item = (), Error = Error>> {
1906 let q = ::url::form_urlencoded::Serializer::new(String::new())
1907 .append_pair("force", &force.to_string())
1908 .append_pair("zone", &zone.to_string())
1909 .append_pair("provider", &provider.to_string())
1910 .finish();
1911 let uri = format!(
1912 "{}/platform/1/auth/groups/{AuthGroupId}?{}",
1913 self.configuration.base_path,
1914 q,
1915 AuthGroupId = auth_group_id
1916 );
1917 put(self.configuration.borrow(), &uri, &auth_group)
1918 }
1919
1920 fn update_auth_log_level(
1921 &self,
1922 auth_log_level: crate::models::AuthLogLevelExtended,
1923 ) -> Box<dyn Future<Item = (), Error = Error>> {
1924 let uri = format!("{}/platform/3/auth/log-level", self.configuration.base_path);
1925 put(self.configuration.borrow(), &uri, &auth_log_level)
1926 }
1927
1928 fn update_auth_role(
1929 &self,
1930 auth_role: crate::models::AuthRole,
1931 auth_role_id: &str,
1932 ) -> Box<dyn Future<Item = (), Error = Error>> {
1933 let uri = format!(
1934 "{}/platform/1/auth/roles/{AuthRoleId}",
1935 self.configuration.base_path,
1936 AuthRoleId = auth_role_id
1937 );
1938 put(self.configuration.borrow(), &uri, &auth_role)
1939 }
1940
1941 fn update_auth_user(
1942 &self,
1943 auth_user: crate::models::AuthUser,
1944 auth_user_id: &str,
1945 force: bool,
1946 zone: &str,
1947 provider: &str,
1948 ) -> Box<dyn Future<Item = (), Error = Error>> {
1949 let q = ::url::form_urlencoded::Serializer::new(String::new())
1950 .append_pair("force", &force.to_string())
1951 .append_pair("zone", &zone.to_string())
1952 .append_pair("provider", &provider.to_string())
1953 .finish();
1954 let uri = format!(
1955 "{}/platform/1/auth/users/{AuthUserId}?{}",
1956 self.configuration.base_path,
1957 q,
1958 AuthUserId = auth_user_id
1959 );
1960 put(self.configuration.borrow(), &uri, &auth_user)
1961 }
1962
1963 fn update_mapping_import(
1964 &self,
1965 mapping_import: crate::models::MappingImport,
1966 zone: &str,
1967 replace: bool,
1968 ) -> Box<dyn Future<Item = (), Error = Error>> {
1969 let q = ::url::form_urlencoded::Serializer::new(String::new())
1970 .append_pair("zone", &zone.to_string())
1971 .append_pair("replace", &replace.to_string())
1972 .finish();
1973 let uri = format!(
1974 "{}/platform/3/auth/mapping/import?{}",
1975 self.configuration.base_path, q
1976 );
1977 put(self.configuration.borrow(), &uri, &mapping_import)
1978 }
1979
1980 fn update_mapping_users_rules(
1981 &self,
1982 mapping_users_rules: crate::models::MappingUsersRulesExtended,
1983 zone: &str,
1984 ) -> Box<dyn Future<Item = (), Error = Error>> {
1985 let q = ::url::form_urlencoded::Serializer::new(String::new())
1986 .append_pair("zone", &zone.to_string())
1987 .finish();
1988 let uri = format!(
1989 "{}/platform/1/auth/mapping/users/rules?{}",
1990 self.configuration.base_path, q
1991 );
1992 put(self.configuration.borrow(), &uri, &mapping_users_rules)
1993 }
1994
1995 fn update_providers_ads_by_id(
1996 &self,
1997 providers_ads_id_params: crate::models::ProvidersAdsIdParams,
1998 providers_ads_id: &str,
1999 ) -> Box<dyn Future<Item = (), Error = Error>> {
2000 let uri = format!(
2001 "{}/platform/3/auth/providers/ads/{ProvidersAdsId}",
2002 self.configuration.base_path,
2003 ProvidersAdsId = providers_ads_id
2004 );
2005 put(self.configuration.borrow(), &uri, &providers_ads_id_params)
2006 }
2007
2008 fn update_providers_file_by_id(
2009 &self,
2010 providers_file_id_params: crate::models::ProvidersFileIdParams,
2011 providers_file_id: &str,
2012 ) -> Box<dyn Future<Item = (), Error = Error>> {
2013 let uri = format!(
2014 "{}/platform/1/auth/providers/file/{ProvidersFileId}",
2015 self.configuration.base_path,
2016 ProvidersFileId = providers_file_id
2017 );
2018 put(self.configuration.borrow(), &uri, &providers_file_id_params)
2019 }
2020
2021 fn update_providers_krb5_by_id(
2022 &self,
2023 providers_krb5_id_params: crate::models::ProvidersKrb5IdParams,
2024 providers_krb5_id: &str,
2025 ) -> Box<dyn Future<Item = (), Error = Error>> {
2026 let uri = format!(
2027 "{}/platform/3/auth/providers/krb5/{ProvidersKrb5Id}",
2028 self.configuration.base_path,
2029 ProvidersKrb5Id = providers_krb5_id
2030 );
2031 put(self.configuration.borrow(), &uri, &providers_krb5_id_params)
2032 }
2033
2034 fn update_providers_ldap_by_id(
2035 &self,
2036 providers_ldap_id_params: crate::models::ProvidersLdapIdParams,
2037 providers_ldap_id: &str,
2038 force: bool,
2039 ) -> Box<dyn Future<Item = (), Error = Error>> {
2040 let q = ::url::form_urlencoded::Serializer::new(String::new())
2041 .append_pair("force", &force.to_string())
2042 .finish();
2043 let uri = format!(
2044 "{}/platform/4/auth/providers/ldap/{ProvidersLdapId}?{}",
2045 self.configuration.base_path,
2046 q,
2047 ProvidersLdapId = providers_ldap_id
2048 );
2049 put(self.configuration.borrow(), &uri, &providers_ldap_id_params)
2050 }
2051
2052 fn update_providers_local_by_id(
2053 &self,
2054 providers_local_id_params: crate::models::ProvidersLocalIdParams,
2055 providers_local_id: &str,
2056 ) -> Box<dyn Future<Item = (), Error = Error>> {
2057 let uri = format!(
2058 "{}/platform/1/auth/providers/local/{ProvidersLocalId}",
2059 self.configuration.base_path,
2060 ProvidersLocalId = providers_local_id
2061 );
2062 put(
2063 self.configuration.borrow(),
2064 &uri,
2065 &providers_local_id_params,
2066 )
2067 }
2068
2069 fn update_providers_nis_by_id(
2070 &self,
2071 providers_nis_id_params: crate::models::ProvidersNisIdParams,
2072 providers_nis_id: &str,
2073 ) -> Box<Future<Item = (), Error = Error>> {
2074 let uri = format!(
2075 "{}/platform/3/auth/providers/nis/{ProvidersNisId}",
2076 self.configuration.base_path,
2077 ProvidersNisId = providers_nis_id
2078 );
2079 put(self.configuration.borrow(), &uri, &providers_nis_id_params)
2080 }
2081
2082 fn update_settings_acls(
2083 &self,
2084 settings_acls: crate::models::SettingsAclsExtended,
2085 ) -> Box<Future<Item = (), Error = Error>> {
2086 let uri = format!(
2087 "{}/platform/3/auth/settings/acls",
2088 self.configuration.base_path
2089 );
2090 put(self.configuration.borrow(), &uri, &settings_acls)
2091 }
2092
2093 fn update_settings_global(
2094 &self,
2095 settings_global: crate::models::SettingsGlobalGlobalSettings,
2096 zone: &str,
2097 ) -> Box<Future<Item = (), Error = Error>> {
2098 let q = ::url::form_urlencoded::Serializer::new(String::new())
2099 .append_pair("zone", &zone.to_string())
2100 .finish();
2101 let uri = format!(
2102 "{}/platform/1/auth/settings/global?{}",
2103 self.configuration.base_path, q
2104 );
2105 put(self.configuration.borrow(), &uri, &settings_global)
2106 }
2107
2108 fn update_settings_krb5_defaults(
2109 &self,
2110 settings_krb5_defaults: crate::models::SettingsKrb5DefaultsKrb5Settings,
2111 ) -> Box<Future<Item = (), Error = Error>> {
2112 let uri = format!(
2113 "{}/platform/1/auth/settings/krb5/defaults",
2114 self.configuration.base_path
2115 );
2116 put(self.configuration.borrow(), &uri, &settings_krb5_defaults)
2117 }
2118
2119 fn update_settings_krb5_domain(
2120 &self,
2121 settings_krb5_domain: crate::models::SettingsKrb5Domain,
2122 settings_krb5_domain_id: &str,
2123 ) -> Box<Future<Item = (), Error = Error>> {
2124 let uri = format!(
2125 "{}/platform/1/auth/settings/krb5/domains/{SettingsKrb5DomainId}",
2126 self.configuration.base_path,
2127 SettingsKrb5DomainId = settings_krb5_domain_id
2128 );
2129 put(self.configuration.borrow(), &uri, &settings_krb5_domain)
2130 }
2131
2132 fn update_settings_krb5_realm(
2133 &self,
2134 settings_krb5_realm: crate::models::SettingsKrb5Realm,
2135 settings_krb5_realm_id: &str,
2136 ) -> Box<Future<Item = (), Error = Error>> {
2137 let uri = format!(
2138 "{}/platform/1/auth/settings/krb5/realms/{SettingsKrb5RealmId}",
2139 self.configuration.base_path,
2140 SettingsKrb5RealmId = settings_krb5_realm_id
2141 );
2142 put(self.configuration.borrow(), &uri, &settings_krb5_realm)
2143 }
2144
2145 fn update_settings_mapping(
2146 &self,
2147 settings_mapping: crate::models::SettingsMappingMappingSettings,
2148 zone: &str,
2149 ) -> Box<Future<Item = (), Error = Error>> {
2150 let q = ::url::form_urlencoded::Serializer::new(String::new())
2151 .append_pair("zone", &zone.to_string())
2152 .finish();
2153 let uri = format!(
2154 "{}/platform/1/auth/settings/mapping?{}",
2155 self.configuration.base_path, q
2156 );
2157 put(self.configuration.borrow(), &uri, &settings_mapping)
2158 }
2159}