1use reqwest;
13
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration};
16
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum RacConnectionTokensDestroyError {
22 Status400(models::ValidationError),
23 Status403(models::GenericError),
24 UnknownValue(serde_json::Value),
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
29#[serde(untagged)]
30pub enum RacConnectionTokensListError {
31 Status400(models::ValidationError),
32 Status403(models::GenericError),
33 UnknownValue(serde_json::Value),
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum RacConnectionTokensPartialUpdateError {
40 Status400(models::ValidationError),
41 Status403(models::GenericError),
42 UnknownValue(serde_json::Value),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
47#[serde(untagged)]
48pub enum RacConnectionTokensRetrieveError {
49 Status400(models::ValidationError),
50 Status403(models::GenericError),
51 UnknownValue(serde_json::Value),
52}
53
54#[derive(Debug, Clone, Serialize, Deserialize)]
56#[serde(untagged)]
57pub enum RacConnectionTokensUpdateError {
58 Status400(models::ValidationError),
59 Status403(models::GenericError),
60 UnknownValue(serde_json::Value),
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(untagged)]
66pub enum RacConnectionTokensUsedByListError {
67 Status400(models::ValidationError),
68 Status403(models::GenericError),
69 UnknownValue(serde_json::Value),
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
74#[serde(untagged)]
75pub enum RacEndpointsCreateError {
76 Status400(models::ValidationError),
77 Status403(models::GenericError),
78 UnknownValue(serde_json::Value),
79}
80
81#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum RacEndpointsDestroyError {
85 Status400(models::ValidationError),
86 Status403(models::GenericError),
87 UnknownValue(serde_json::Value),
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[serde(untagged)]
93pub enum RacEndpointsListError {
94 Status400(),
95 Status403(models::GenericError),
96 UnknownValue(serde_json::Value),
97}
98
99#[derive(Debug, Clone, Serialize, Deserialize)]
101#[serde(untagged)]
102pub enum RacEndpointsPartialUpdateError {
103 Status400(models::ValidationError),
104 Status403(models::GenericError),
105 UnknownValue(serde_json::Value),
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(untagged)]
111pub enum RacEndpointsRetrieveError {
112 Status400(models::ValidationError),
113 Status403(models::GenericError),
114 UnknownValue(serde_json::Value),
115}
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
119#[serde(untagged)]
120pub enum RacEndpointsUpdateError {
121 Status400(models::ValidationError),
122 Status403(models::GenericError),
123 UnknownValue(serde_json::Value),
124}
125
126#[derive(Debug, Clone, Serialize, Deserialize)]
128#[serde(untagged)]
129pub enum RacEndpointsUsedByListError {
130 Status400(models::ValidationError),
131 Status403(models::GenericError),
132 UnknownValue(serde_json::Value),
133}
134
135
136pub async fn rac_connection_tokens_destroy(configuration: &configuration::Configuration, connection_token_uuid: &str) -> Result<(), Error<RacConnectionTokensDestroyError>> {
138 let local_var_configuration = configuration;
139
140 let local_var_client = &local_var_configuration.client;
141
142 let local_var_uri_str = format!("{}/rac/connection_tokens/{connection_token_uuid}/", local_var_configuration.base_path, connection_token_uuid=crate::apis::urlencode(connection_token_uuid));
143 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
144
145 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
146 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
147 }
148 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
149 let local_var_key = local_var_apikey.key.clone();
150 let local_var_value = match local_var_apikey.prefix {
151 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
152 None => local_var_key,
153 };
154 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
155 };
156
157 let local_var_req = local_var_req_builder.build()?;
158 let local_var_resp = local_var_client.execute(local_var_req).await?;
159
160 let local_var_status = local_var_resp.status();
161 let local_var_content = local_var_resp.text().await?;
162
163 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
164 Ok(())
165 } else {
166 let local_var_entity: Option<RacConnectionTokensDestroyError> = serde_json::from_str(&local_var_content).ok();
167 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
168 Err(Error::ResponseError(local_var_error))
169 }
170}
171
172pub async fn rac_connection_tokens_list(configuration: &configuration::Configuration, endpoint: Option<&str>, ordering: Option<&str>, page: Option<i32>, page_size: Option<i32>, provider: Option<i32>, search: Option<&str>, session__user: Option<i32>) -> Result<models::PaginatedConnectionTokenList, Error<RacConnectionTokensListError>> {
174 let local_var_configuration = configuration;
175
176 let local_var_client = &local_var_configuration.client;
177
178 let local_var_uri_str = format!("{}/rac/connection_tokens/", local_var_configuration.base_path);
179 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
180
181 if let Some(ref local_var_str) = endpoint {
182 local_var_req_builder = local_var_req_builder.query(&[("endpoint", &local_var_str.to_string())]);
183 }
184 if let Some(ref local_var_str) = ordering {
185 local_var_req_builder = local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
186 }
187 if let Some(ref local_var_str) = page {
188 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
189 }
190 if let Some(ref local_var_str) = page_size {
191 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
192 }
193 if let Some(ref local_var_str) = provider {
194 local_var_req_builder = local_var_req_builder.query(&[("provider", &local_var_str.to_string())]);
195 }
196 if let Some(ref local_var_str) = search {
197 local_var_req_builder = local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
198 }
199 if let Some(ref local_var_str) = session__user {
200 local_var_req_builder = local_var_req_builder.query(&[("session__user", &local_var_str.to_string())]);
201 }
202 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
203 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
204 }
205 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
206 let local_var_key = local_var_apikey.key.clone();
207 let local_var_value = match local_var_apikey.prefix {
208 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
209 None => local_var_key,
210 };
211 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
212 };
213
214 let local_var_req = local_var_req_builder.build()?;
215 let local_var_resp = local_var_client.execute(local_var_req).await?;
216
217 let local_var_status = local_var_resp.status();
218 let local_var_content = local_var_resp.text().await?;
219
220 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
221 serde_json::from_str(&local_var_content).map_err(Error::from)
222 } else {
223 let local_var_entity: Option<RacConnectionTokensListError> = serde_json::from_str(&local_var_content).ok();
224 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
225 Err(Error::ResponseError(local_var_error))
226 }
227}
228
229pub async fn rac_connection_tokens_partial_update(configuration: &configuration::Configuration, connection_token_uuid: &str, patched_connection_token_request: Option<models::PatchedConnectionTokenRequest>) -> Result<models::ConnectionToken, Error<RacConnectionTokensPartialUpdateError>> {
231 let local_var_configuration = configuration;
232
233 let local_var_client = &local_var_configuration.client;
234
235 let local_var_uri_str = format!("{}/rac/connection_tokens/{connection_token_uuid}/", local_var_configuration.base_path, connection_token_uuid=crate::apis::urlencode(connection_token_uuid));
236 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
237
238 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
239 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
240 }
241 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
242 let local_var_key = local_var_apikey.key.clone();
243 let local_var_value = match local_var_apikey.prefix {
244 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
245 None => local_var_key,
246 };
247 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
248 };
249 local_var_req_builder = local_var_req_builder.json(&patched_connection_token_request);
250
251 let local_var_req = local_var_req_builder.build()?;
252 let local_var_resp = local_var_client.execute(local_var_req).await?;
253
254 let local_var_status = local_var_resp.status();
255 let local_var_content = local_var_resp.text().await?;
256
257 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
258 serde_json::from_str(&local_var_content).map_err(Error::from)
259 } else {
260 let local_var_entity: Option<RacConnectionTokensPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
261 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
262 Err(Error::ResponseError(local_var_error))
263 }
264}
265
266pub async fn rac_connection_tokens_retrieve(configuration: &configuration::Configuration, connection_token_uuid: &str) -> Result<models::ConnectionToken, Error<RacConnectionTokensRetrieveError>> {
268 let local_var_configuration = configuration;
269
270 let local_var_client = &local_var_configuration.client;
271
272 let local_var_uri_str = format!("{}/rac/connection_tokens/{connection_token_uuid}/", local_var_configuration.base_path, connection_token_uuid=crate::apis::urlencode(connection_token_uuid));
273 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
274
275 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
276 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
277 }
278 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
279 let local_var_key = local_var_apikey.key.clone();
280 let local_var_value = match local_var_apikey.prefix {
281 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
282 None => local_var_key,
283 };
284 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
285 };
286
287 let local_var_req = local_var_req_builder.build()?;
288 let local_var_resp = local_var_client.execute(local_var_req).await?;
289
290 let local_var_status = local_var_resp.status();
291 let local_var_content = local_var_resp.text().await?;
292
293 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
294 serde_json::from_str(&local_var_content).map_err(Error::from)
295 } else {
296 let local_var_entity: Option<RacConnectionTokensRetrieveError> = serde_json::from_str(&local_var_content).ok();
297 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
298 Err(Error::ResponseError(local_var_error))
299 }
300}
301
302pub async fn rac_connection_tokens_update(configuration: &configuration::Configuration, connection_token_uuid: &str, connection_token_request: models::ConnectionTokenRequest) -> Result<models::ConnectionToken, Error<RacConnectionTokensUpdateError>> {
304 let local_var_configuration = configuration;
305
306 let local_var_client = &local_var_configuration.client;
307
308 let local_var_uri_str = format!("{}/rac/connection_tokens/{connection_token_uuid}/", local_var_configuration.base_path, connection_token_uuid=crate::apis::urlencode(connection_token_uuid));
309 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
310
311 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
312 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
313 }
314 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
315 let local_var_key = local_var_apikey.key.clone();
316 let local_var_value = match local_var_apikey.prefix {
317 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
318 None => local_var_key,
319 };
320 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
321 };
322 local_var_req_builder = local_var_req_builder.json(&connection_token_request);
323
324 let local_var_req = local_var_req_builder.build()?;
325 let local_var_resp = local_var_client.execute(local_var_req).await?;
326
327 let local_var_status = local_var_resp.status();
328 let local_var_content = local_var_resp.text().await?;
329
330 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
331 serde_json::from_str(&local_var_content).map_err(Error::from)
332 } else {
333 let local_var_entity: Option<RacConnectionTokensUpdateError> = serde_json::from_str(&local_var_content).ok();
334 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
335 Err(Error::ResponseError(local_var_error))
336 }
337}
338
339pub async fn rac_connection_tokens_used_by_list(configuration: &configuration::Configuration, connection_token_uuid: &str) -> Result<Vec<models::UsedBy>, Error<RacConnectionTokensUsedByListError>> {
341 let local_var_configuration = configuration;
342
343 let local_var_client = &local_var_configuration.client;
344
345 let local_var_uri_str = format!("{}/rac/connection_tokens/{connection_token_uuid}/used_by/", local_var_configuration.base_path, connection_token_uuid=crate::apis::urlencode(connection_token_uuid));
346 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
347
348 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
349 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
350 }
351 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
352 let local_var_key = local_var_apikey.key.clone();
353 let local_var_value = match local_var_apikey.prefix {
354 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
355 None => local_var_key,
356 };
357 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
358 };
359
360 let local_var_req = local_var_req_builder.build()?;
361 let local_var_resp = local_var_client.execute(local_var_req).await?;
362
363 let local_var_status = local_var_resp.status();
364 let local_var_content = local_var_resp.text().await?;
365
366 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
367 serde_json::from_str(&local_var_content).map_err(Error::from)
368 } else {
369 let local_var_entity: Option<RacConnectionTokensUsedByListError> = serde_json::from_str(&local_var_content).ok();
370 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
371 Err(Error::ResponseError(local_var_error))
372 }
373}
374
375pub async fn rac_endpoints_create(configuration: &configuration::Configuration, endpoint_request: models::EndpointRequest) -> Result<models::Endpoint, Error<RacEndpointsCreateError>> {
377 let local_var_configuration = configuration;
378
379 let local_var_client = &local_var_configuration.client;
380
381 let local_var_uri_str = format!("{}/rac/endpoints/", local_var_configuration.base_path);
382 let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
383
384 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
385 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
386 }
387 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
388 let local_var_key = local_var_apikey.key.clone();
389 let local_var_value = match local_var_apikey.prefix {
390 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
391 None => local_var_key,
392 };
393 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
394 };
395 local_var_req_builder = local_var_req_builder.json(&endpoint_request);
396
397 let local_var_req = local_var_req_builder.build()?;
398 let local_var_resp = local_var_client.execute(local_var_req).await?;
399
400 let local_var_status = local_var_resp.status();
401 let local_var_content = local_var_resp.text().await?;
402
403 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
404 serde_json::from_str(&local_var_content).map_err(Error::from)
405 } else {
406 let local_var_entity: Option<RacEndpointsCreateError> = serde_json::from_str(&local_var_content).ok();
407 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
408 Err(Error::ResponseError(local_var_error))
409 }
410}
411
412pub async fn rac_endpoints_destroy(configuration: &configuration::Configuration, pbm_uuid: &str) -> Result<(), Error<RacEndpointsDestroyError>> {
414 let local_var_configuration = configuration;
415
416 let local_var_client = &local_var_configuration.client;
417
418 let local_var_uri_str = format!("{}/rac/endpoints/{pbm_uuid}/", local_var_configuration.base_path, pbm_uuid=crate::apis::urlencode(pbm_uuid));
419 let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
420
421 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
422 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
423 }
424 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
425 let local_var_key = local_var_apikey.key.clone();
426 let local_var_value = match local_var_apikey.prefix {
427 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
428 None => local_var_key,
429 };
430 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
431 };
432
433 let local_var_req = local_var_req_builder.build()?;
434 let local_var_resp = local_var_client.execute(local_var_req).await?;
435
436 let local_var_status = local_var_resp.status();
437 let local_var_content = local_var_resp.text().await?;
438
439 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
440 Ok(())
441 } else {
442 let local_var_entity: Option<RacEndpointsDestroyError> = serde_json::from_str(&local_var_content).ok();
443 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
444 Err(Error::ResponseError(local_var_error))
445 }
446}
447
448pub async fn rac_endpoints_list(configuration: &configuration::Configuration, name: Option<&str>, ordering: Option<&str>, page: Option<i32>, page_size: Option<i32>, provider: Option<i32>, search: Option<&str>, superuser_full_list: Option<bool>) -> Result<models::PaginatedEndpointList, Error<RacEndpointsListError>> {
450 let local_var_configuration = configuration;
451
452 let local_var_client = &local_var_configuration.client;
453
454 let local_var_uri_str = format!("{}/rac/endpoints/", local_var_configuration.base_path);
455 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
456
457 if let Some(ref local_var_str) = name {
458 local_var_req_builder = local_var_req_builder.query(&[("name", &local_var_str.to_string())]);
459 }
460 if let Some(ref local_var_str) = ordering {
461 local_var_req_builder = local_var_req_builder.query(&[("ordering", &local_var_str.to_string())]);
462 }
463 if let Some(ref local_var_str) = page {
464 local_var_req_builder = local_var_req_builder.query(&[("page", &local_var_str.to_string())]);
465 }
466 if let Some(ref local_var_str) = page_size {
467 local_var_req_builder = local_var_req_builder.query(&[("page_size", &local_var_str.to_string())]);
468 }
469 if let Some(ref local_var_str) = provider {
470 local_var_req_builder = local_var_req_builder.query(&[("provider", &local_var_str.to_string())]);
471 }
472 if let Some(ref local_var_str) = search {
473 local_var_req_builder = local_var_req_builder.query(&[("search", &local_var_str.to_string())]);
474 }
475 if let Some(ref local_var_str) = superuser_full_list {
476 local_var_req_builder = local_var_req_builder.query(&[("superuser_full_list", &local_var_str.to_string())]);
477 }
478 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
479 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
480 }
481 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
482 let local_var_key = local_var_apikey.key.clone();
483 let local_var_value = match local_var_apikey.prefix {
484 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
485 None => local_var_key,
486 };
487 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
488 };
489
490 let local_var_req = local_var_req_builder.build()?;
491 let local_var_resp = local_var_client.execute(local_var_req).await?;
492
493 let local_var_status = local_var_resp.status();
494 let local_var_content = local_var_resp.text().await?;
495
496 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
497 serde_json::from_str(&local_var_content).map_err(Error::from)
498 } else {
499 let local_var_entity: Option<RacEndpointsListError> = serde_json::from_str(&local_var_content).ok();
500 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
501 Err(Error::ResponseError(local_var_error))
502 }
503}
504
505pub async fn rac_endpoints_partial_update(configuration: &configuration::Configuration, pbm_uuid: &str, patched_endpoint_request: Option<models::PatchedEndpointRequest>) -> Result<models::Endpoint, Error<RacEndpointsPartialUpdateError>> {
507 let local_var_configuration = configuration;
508
509 let local_var_client = &local_var_configuration.client;
510
511 let local_var_uri_str = format!("{}/rac/endpoints/{pbm_uuid}/", local_var_configuration.base_path, pbm_uuid=crate::apis::urlencode(pbm_uuid));
512 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PATCH, local_var_uri_str.as_str());
513
514 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
515 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
516 }
517 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
518 let local_var_key = local_var_apikey.key.clone();
519 let local_var_value = match local_var_apikey.prefix {
520 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
521 None => local_var_key,
522 };
523 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
524 };
525 local_var_req_builder = local_var_req_builder.json(&patched_endpoint_request);
526
527 let local_var_req = local_var_req_builder.build()?;
528 let local_var_resp = local_var_client.execute(local_var_req).await?;
529
530 let local_var_status = local_var_resp.status();
531 let local_var_content = local_var_resp.text().await?;
532
533 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
534 serde_json::from_str(&local_var_content).map_err(Error::from)
535 } else {
536 let local_var_entity: Option<RacEndpointsPartialUpdateError> = serde_json::from_str(&local_var_content).ok();
537 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
538 Err(Error::ResponseError(local_var_error))
539 }
540}
541
542pub async fn rac_endpoints_retrieve(configuration: &configuration::Configuration, pbm_uuid: &str) -> Result<models::Endpoint, Error<RacEndpointsRetrieveError>> {
544 let local_var_configuration = configuration;
545
546 let local_var_client = &local_var_configuration.client;
547
548 let local_var_uri_str = format!("{}/rac/endpoints/{pbm_uuid}/", local_var_configuration.base_path, pbm_uuid=crate::apis::urlencode(pbm_uuid));
549 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
550
551 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
552 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
553 }
554 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
555 let local_var_key = local_var_apikey.key.clone();
556 let local_var_value = match local_var_apikey.prefix {
557 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
558 None => local_var_key,
559 };
560 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
561 };
562
563 let local_var_req = local_var_req_builder.build()?;
564 let local_var_resp = local_var_client.execute(local_var_req).await?;
565
566 let local_var_status = local_var_resp.status();
567 let local_var_content = local_var_resp.text().await?;
568
569 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
570 serde_json::from_str(&local_var_content).map_err(Error::from)
571 } else {
572 let local_var_entity: Option<RacEndpointsRetrieveError> = serde_json::from_str(&local_var_content).ok();
573 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
574 Err(Error::ResponseError(local_var_error))
575 }
576}
577
578pub async fn rac_endpoints_update(configuration: &configuration::Configuration, pbm_uuid: &str, endpoint_request: models::EndpointRequest) -> Result<models::Endpoint, Error<RacEndpointsUpdateError>> {
580 let local_var_configuration = configuration;
581
582 let local_var_client = &local_var_configuration.client;
583
584 let local_var_uri_str = format!("{}/rac/endpoints/{pbm_uuid}/", local_var_configuration.base_path, pbm_uuid=crate::apis::urlencode(pbm_uuid));
585 let mut local_var_req_builder = local_var_client.request(reqwest::Method::PUT, local_var_uri_str.as_str());
586
587 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
588 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
589 }
590 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
591 let local_var_key = local_var_apikey.key.clone();
592 let local_var_value = match local_var_apikey.prefix {
593 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
594 None => local_var_key,
595 };
596 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
597 };
598 local_var_req_builder = local_var_req_builder.json(&endpoint_request);
599
600 let local_var_req = local_var_req_builder.build()?;
601 let local_var_resp = local_var_client.execute(local_var_req).await?;
602
603 let local_var_status = local_var_resp.status();
604 let local_var_content = local_var_resp.text().await?;
605
606 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
607 serde_json::from_str(&local_var_content).map_err(Error::from)
608 } else {
609 let local_var_entity: Option<RacEndpointsUpdateError> = serde_json::from_str(&local_var_content).ok();
610 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
611 Err(Error::ResponseError(local_var_error))
612 }
613}
614
615pub async fn rac_endpoints_used_by_list(configuration: &configuration::Configuration, pbm_uuid: &str) -> Result<Vec<models::UsedBy>, Error<RacEndpointsUsedByListError>> {
617 let local_var_configuration = configuration;
618
619 let local_var_client = &local_var_configuration.client;
620
621 let local_var_uri_str = format!("{}/rac/endpoints/{pbm_uuid}/used_by/", local_var_configuration.base_path, pbm_uuid=crate::apis::urlencode(pbm_uuid));
622 let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
623
624 if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
625 local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
626 }
627 if let Some(ref local_var_apikey) = local_var_configuration.api_key {
628 let local_var_key = local_var_apikey.key.clone();
629 let local_var_value = match local_var_apikey.prefix {
630 Some(ref local_var_prefix) => format!("{} {}", local_var_prefix, local_var_key),
631 None => local_var_key,
632 };
633 local_var_req_builder = local_var_req_builder.header("Authorization", local_var_value);
634 };
635
636 let local_var_req = local_var_req_builder.build()?;
637 let local_var_resp = local_var_client.execute(local_var_req).await?;
638
639 let local_var_status = local_var_resp.status();
640 let local_var_content = local_var_resp.text().await?;
641
642 if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
643 serde_json::from_str(&local_var_content).map_err(Error::from)
644 } else {
645 let local_var_entity: Option<RacEndpointsUsedByListError> = serde_json::from_str(&local_var_content).ok();
646 let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
647 Err(Error::ResponseError(local_var_error))
648 }
649}
650