1use reqwest;
12
13use super::{configuration, Error};
14use crate::apis::ResponseContent;
15
16#[derive(Debug, Clone, Serialize, Deserialize)]
18#[serde(untagged)]
19pub enum AddUserToUserGroupError {
20 UnknownValue(serde_json::Value),
21}
22
23#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(untagged)]
26pub enum CreateUserGroupError {
27 UnknownValue(serde_json::Value),
28}
29
30#[derive(Debug, Clone, Serialize, Deserialize)]
32#[serde(untagged)]
33pub enum DeleteUserGroupError {
34 UnknownValue(serde_json::Value),
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
39#[serde(untagged)]
40pub enum ReadUserGroupError {
41 UnknownValue(serde_json::Value),
42}
43
44#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(untagged)]
47pub enum ReadUserGroupsError {
48 UnknownValue(serde_json::Value),
49}
50
51#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum ReadUserGroupsPerUserError {
55 UnknownValue(serde_json::Value),
56}
57
58#[derive(Debug, Clone, Serialize, Deserialize)]
60#[serde(untagged)]
61pub enum RemoveUserFromUserGroupError {
62 UnknownValue(serde_json::Value),
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum UpdateUserGroupError {
69 UnknownValue(serde_json::Value),
70}
71
72pub fn add_user_to_user_group(
73 configuration: &configuration::Configuration,
74 add_user_to_user_group_request: Option<crate::models::AddUserToUserGroupRequest>,
75) -> Result<crate::models::AddUserToUserGroupResponse, Error<AddUserToUserGroupError>> {
76 let local_var_configuration = configuration;
77
78 let local_var_client = &local_var_configuration.client;
79
80 let local_var_uri_str = format!("{}/AddUserToUserGroup", local_var_configuration.base_path);
81 let mut local_var_req_builder =
82 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
83
84 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
85 let local_var_new_headers = match local_var_aws_v4_key.sign(
86 &local_var_uri_str,
87 "POST",
88 &serde_json::to_string(&add_user_to_user_group_request)
89 .expect("param should serialize to string"),
90 ) {
91 Ok(new_headers) => new_headers,
92 Err(err) => return Err(Error::AWSV4SignatureError(err)),
93 };
94 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
95 local_var_req_builder =
96 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
97 }
98 }
99 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
100 local_var_req_builder =
101 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
102 }
103 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
104 let local_var_key = local_var_apikey.key.clone();
105 let local_var_value = match local_var_apikey.prefix {
106 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
107 None => local_var_key,
108 };
109 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
110 };
111 local_var_req_builder = local_var_req_builder.json(&add_user_to_user_group_request);
112
113 let local_var_req = local_var_req_builder.build()?;
114 let mut local_var_resp = local_var_client.execute(local_var_req)?;
115
116 let local_var_status = local_var_resp.status();
117 let local_var_content = local_var_resp.text()?;
118
119 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
120 serde_json::from_str(&local_var_content).map_err(Error::from)
121 } else {
122 let local_var_entity: Option<AddUserToUserGroupError> =
123 serde_json::from_str(&local_var_content).ok();
124 let local_var_error = ResponseContent {
125 status: local_var_status,
126 content: local_var_content,
127 entity: local_var_entity,
128 };
129 Err(Error::ResponseError(local_var_error))
130 }
131}
132
133pub fn create_user_group(
134 configuration: &configuration::Configuration,
135 create_user_group_request: Option<crate::models::CreateUserGroupRequest>,
136) -> Result<crate::models::CreateUserGroupResponse, Error<CreateUserGroupError>> {
137 let local_var_configuration = configuration;
138
139 let local_var_client = &local_var_configuration.client;
140
141 let local_var_uri_str = format!("{}/CreateUserGroup", local_var_configuration.base_path);
142 let mut local_var_req_builder =
143 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
144
145 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
146 let local_var_new_headers = match local_var_aws_v4_key.sign(
147 &local_var_uri_str,
148 "POST",
149 &serde_json::to_string(&create_user_group_request)
150 .expect("param should serialize to string"),
151 ) {
152 Ok(new_headers) => new_headers,
153 Err(err) => return Err(Error::AWSV4SignatureError(err)),
154 };
155 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
156 local_var_req_builder =
157 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
158 }
159 }
160 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
161 local_var_req_builder =
162 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
163 }
164 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
165 let local_var_key = local_var_apikey.key.clone();
166 let local_var_value = match local_var_apikey.prefix {
167 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
168 None => local_var_key,
169 };
170 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
171 };
172 local_var_req_builder = local_var_req_builder.json(&create_user_group_request);
173
174 let local_var_req = local_var_req_builder.build()?;
175 let mut local_var_resp = local_var_client.execute(local_var_req)?;
176
177 let local_var_status = local_var_resp.status();
178 let local_var_content = local_var_resp.text()?;
179
180 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
181 serde_json::from_str(&local_var_content).map_err(Error::from)
182 } else {
183 let local_var_entity: Option<CreateUserGroupError> =
184 serde_json::from_str(&local_var_content).ok();
185 let local_var_error = ResponseContent {
186 status: local_var_status,
187 content: local_var_content,
188 entity: local_var_entity,
189 };
190 Err(Error::ResponseError(local_var_error))
191 }
192}
193
194pub fn delete_user_group(
195 configuration: &configuration::Configuration,
196 delete_user_group_request: Option<crate::models::DeleteUserGroupRequest>,
197) -> Result<crate::models::DeleteUserGroupResponse, Error<DeleteUserGroupError>> {
198 let local_var_configuration = configuration;
199
200 let local_var_client = &local_var_configuration.client;
201
202 let local_var_uri_str = format!("{}/DeleteUserGroup", local_var_configuration.base_path);
203 let mut local_var_req_builder =
204 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
205
206 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
207 let local_var_new_headers = match local_var_aws_v4_key.sign(
208 &local_var_uri_str,
209 "POST",
210 &serde_json::to_string(&delete_user_group_request)
211 .expect("param should serialize to string"),
212 ) {
213 Ok(new_headers) => new_headers,
214 Err(err) => return Err(Error::AWSV4SignatureError(err)),
215 };
216 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
217 local_var_req_builder =
218 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
219 }
220 }
221 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
222 local_var_req_builder =
223 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
224 }
225 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
226 let local_var_key = local_var_apikey.key.clone();
227 let local_var_value = match local_var_apikey.prefix {
228 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
229 None => local_var_key,
230 };
231 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
232 };
233 local_var_req_builder = local_var_req_builder.json(&delete_user_group_request);
234
235 let local_var_req = local_var_req_builder.build()?;
236 let mut local_var_resp = local_var_client.execute(local_var_req)?;
237
238 let local_var_status = local_var_resp.status();
239 let local_var_content = local_var_resp.text()?;
240
241 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
242 serde_json::from_str(&local_var_content).map_err(Error::from)
243 } else {
244 let local_var_entity: Option<DeleteUserGroupError> =
245 serde_json::from_str(&local_var_content).ok();
246 let local_var_error = ResponseContent {
247 status: local_var_status,
248 content: local_var_content,
249 entity: local_var_entity,
250 };
251 Err(Error::ResponseError(local_var_error))
252 }
253}
254
255pub fn read_user_group(
256 configuration: &configuration::Configuration,
257 read_user_group_request: Option<crate::models::ReadUserGroupRequest>,
258) -> Result<crate::models::ReadUserGroupResponse, Error<ReadUserGroupError>> {
259 let local_var_configuration = configuration;
260
261 let local_var_client = &local_var_configuration.client;
262
263 let local_var_uri_str = format!("{}/ReadUserGroup", local_var_configuration.base_path);
264 let mut local_var_req_builder =
265 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
266
267 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
268 let local_var_new_headers = match local_var_aws_v4_key.sign(
269 &local_var_uri_str,
270 "POST",
271 &serde_json::to_string(&read_user_group_request)
272 .expect("param should serialize to string"),
273 ) {
274 Ok(new_headers) => new_headers,
275 Err(err) => return Err(Error::AWSV4SignatureError(err)),
276 };
277 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
278 local_var_req_builder =
279 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
280 }
281 }
282 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
283 local_var_req_builder =
284 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
285 }
286 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
287 let local_var_key = local_var_apikey.key.clone();
288 let local_var_value = match local_var_apikey.prefix {
289 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
290 None => local_var_key,
291 };
292 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
293 };
294 local_var_req_builder = local_var_req_builder.json(&read_user_group_request);
295
296 let local_var_req = local_var_req_builder.build()?;
297 let mut local_var_resp = local_var_client.execute(local_var_req)?;
298
299 let local_var_status = local_var_resp.status();
300 let local_var_content = local_var_resp.text()?;
301
302 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
303 serde_json::from_str(&local_var_content).map_err(Error::from)
304 } else {
305 let local_var_entity: Option<ReadUserGroupError> =
306 serde_json::from_str(&local_var_content).ok();
307 let local_var_error = ResponseContent {
308 status: local_var_status,
309 content: local_var_content,
310 entity: local_var_entity,
311 };
312 Err(Error::ResponseError(local_var_error))
313 }
314}
315
316pub fn read_user_groups(
317 configuration: &configuration::Configuration,
318 read_user_groups_request: Option<crate::models::ReadUserGroupsRequest>,
319) -> Result<crate::models::ReadUserGroupsResponse, Error<ReadUserGroupsError>> {
320 let local_var_configuration = configuration;
321
322 let local_var_client = &local_var_configuration.client;
323
324 let local_var_uri_str = format!("{}/ReadUserGroups", local_var_configuration.base_path);
325 let mut local_var_req_builder =
326 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
327
328 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
329 let local_var_new_headers = match local_var_aws_v4_key.sign(
330 &local_var_uri_str,
331 "POST",
332 &serde_json::to_string(&read_user_groups_request)
333 .expect("param should serialize to string"),
334 ) {
335 Ok(new_headers) => new_headers,
336 Err(err) => return Err(Error::AWSV4SignatureError(err)),
337 };
338 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
339 local_var_req_builder =
340 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
341 }
342 }
343 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
344 local_var_req_builder =
345 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
346 }
347 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
348 let local_var_key = local_var_apikey.key.clone();
349 let local_var_value = match local_var_apikey.prefix {
350 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
351 None => local_var_key,
352 };
353 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
354 };
355 local_var_req_builder = local_var_req_builder.json(&read_user_groups_request);
356
357 let local_var_req = local_var_req_builder.build()?;
358 let mut local_var_resp = local_var_client.execute(local_var_req)?;
359
360 let local_var_status = local_var_resp.status();
361 let local_var_content = local_var_resp.text()?;
362
363 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
364 serde_json::from_str(&local_var_content).map_err(Error::from)
365 } else {
366 let local_var_entity: Option<ReadUserGroupsError> =
367 serde_json::from_str(&local_var_content).ok();
368 let local_var_error = ResponseContent {
369 status: local_var_status,
370 content: local_var_content,
371 entity: local_var_entity,
372 };
373 Err(Error::ResponseError(local_var_error))
374 }
375}
376
377pub fn read_user_groups_per_user(
378 configuration: &configuration::Configuration,
379 read_user_groups_per_user_request: Option<crate::models::ReadUserGroupsPerUserRequest>,
380) -> Result<crate::models::ReadUserGroupsPerUserResponse, Error<ReadUserGroupsPerUserError>> {
381 let local_var_configuration = configuration;
382
383 let local_var_client = &local_var_configuration.client;
384
385 let local_var_uri_str = format!(
386 "{}/ReadUserGroupsPerUser",
387 local_var_configuration.base_path
388 );
389 let mut local_var_req_builder =
390 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
391
392 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
393 let local_var_new_headers = match local_var_aws_v4_key.sign(
394 &local_var_uri_str,
395 "POST",
396 &serde_json::to_string(&read_user_groups_per_user_request)
397 .expect("param should serialize to string"),
398 ) {
399 Ok(new_headers) => new_headers,
400 Err(err) => return Err(Error::AWSV4SignatureError(err)),
401 };
402 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
403 local_var_req_builder =
404 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
405 }
406 }
407 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
408 local_var_req_builder =
409 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
410 }
411 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
412 let local_var_key = local_var_apikey.key.clone();
413 let local_var_value = match local_var_apikey.prefix {
414 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
415 None => local_var_key,
416 };
417 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
418 };
419 local_var_req_builder = local_var_req_builder.json(&read_user_groups_per_user_request);
420
421 let local_var_req = local_var_req_builder.build()?;
422 let mut local_var_resp = local_var_client.execute(local_var_req)?;
423
424 let local_var_status = local_var_resp.status();
425 let local_var_content = local_var_resp.text()?;
426
427 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
428 serde_json::from_str(&local_var_content).map_err(Error::from)
429 } else {
430 let local_var_entity: Option<ReadUserGroupsPerUserError> =
431 serde_json::from_str(&local_var_content).ok();
432 let local_var_error = ResponseContent {
433 status: local_var_status,
434 content: local_var_content,
435 entity: local_var_entity,
436 };
437 Err(Error::ResponseError(local_var_error))
438 }
439}
440
441pub fn remove_user_from_user_group(
442 configuration: &configuration::Configuration,
443 remove_user_from_user_group_request: Option<crate::models::RemoveUserFromUserGroupRequest>,
444) -> Result<crate::models::RemoveUserFromUserGroupResponse, Error<RemoveUserFromUserGroupError>> {
445 let local_var_configuration = configuration;
446
447 let local_var_client = &local_var_configuration.client;
448
449 let local_var_uri_str = format!(
450 "{}/RemoveUserFromUserGroup",
451 local_var_configuration.base_path
452 );
453 let mut local_var_req_builder =
454 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
455
456 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
457 let local_var_new_headers = match local_var_aws_v4_key.sign(
458 &local_var_uri_str,
459 "POST",
460 &serde_json::to_string(&remove_user_from_user_group_request)
461 .expect("param should serialize to string"),
462 ) {
463 Ok(new_headers) => new_headers,
464 Err(err) => return Err(Error::AWSV4SignatureError(err)),
465 };
466 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
467 local_var_req_builder =
468 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
469 }
470 }
471 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
472 local_var_req_builder =
473 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
474 }
475 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
476 let local_var_key = local_var_apikey.key.clone();
477 let local_var_value = match local_var_apikey.prefix {
478 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
479 None => local_var_key,
480 };
481 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
482 };
483 local_var_req_builder = local_var_req_builder.json(&remove_user_from_user_group_request);
484
485 let local_var_req = local_var_req_builder.build()?;
486 let mut local_var_resp = local_var_client.execute(local_var_req)?;
487
488 let local_var_status = local_var_resp.status();
489 let local_var_content = local_var_resp.text()?;
490
491 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
492 serde_json::from_str(&local_var_content).map_err(Error::from)
493 } else {
494 let local_var_entity: Option<RemoveUserFromUserGroupError> =
495 serde_json::from_str(&local_var_content).ok();
496 let local_var_error = ResponseContent {
497 status: local_var_status,
498 content: local_var_content,
499 entity: local_var_entity,
500 };
501 Err(Error::ResponseError(local_var_error))
502 }
503}
504
505pub fn update_user_group(
506 configuration: &configuration::Configuration,
507 update_user_group_request: Option<crate::models::UpdateUserGroupRequest>,
508) -> Result<crate::models::UpdateUserGroupResponse, Error<UpdateUserGroupError>> {
509 let local_var_configuration = configuration;
510
511 let local_var_client = &local_var_configuration.client;
512
513 let local_var_uri_str = format!("{}/UpdateUserGroup", local_var_configuration.base_path);
514 let mut local_var_req_builder =
515 local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
516
517 if let Some(ref local_var_aws_v4_key) = local_var_configuration.aws_v4_key {
518 let local_var_new_headers = match local_var_aws_v4_key.sign(
519 &local_var_uri_str,
520 "POST",
521 &serde_json::to_string(&update_user_group_request)
522 .expect("param should serialize to string"),
523 ) {
524 Ok(new_headers) => new_headers,
525 Err(err) => return Err(Error::AWSV4SignatureError(err)),
526 };
527 for (local_var_name, local_var_value) in local_var_new_headers.iter() {
528 local_var_req_builder =
529 local_var_req_builder.header(local_var_name.as_str(), local_var_value.as_str());
530 }
531 }
532 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
533 local_var_req_builder =
534 local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
535 }
536 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
537 let local_var_key = local_var_apikey.key.clone();
538 let local_var_value = match local_var_apikey.prefix {
539 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
540 None => local_var_key,
541 };
542 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
543 };
544 local_var_req_builder = local_var_req_builder.json(&update_user_group_request);
545
546 let local_var_req = local_var_req_builder.build()?;
547 let mut local_var_resp = local_var_client.execute(local_var_req)?;
548
549 let local_var_status = local_var_resp.status();
550 let local_var_content = local_var_resp.text()?;
551
552 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
553 serde_json::from_str(&local_var_content).map_err(Error::from)
554 } else {
555 let local_var_entity: Option<UpdateUserGroupError> =
556 serde_json::from_str(&local_var_content).ok();
557 let local_var_error = ResponseContent {
558 status: local_var_status,
559 content: local_var_content,
560 entity: local_var_entity,
561 };
562 Err(Error::ResponseError(local_var_error))
563 }
564}