dtz_core/apis/
default_api.rs

1/*
2 * DTZ Core Api
3 *
4 * a generated client for the DTZ Core API
5 *
6 * Contact: jens@apimeister.com
7 * Generated by: https://openapi-generator.tech
8 */
9
10
11use reqwest;
12#[allow(unused_imports)]
13use serde::{de::Error as _};
14use crate::{apis::ResponseContent, models};
15#[allow(unused_imports)]
16use super::{Error, ContentType};
17use dtz_config::Configuration;
18
19fn build_url(config: &Configuration) -> String {
20    if let Some(base_path) = &config.base_path {
21        let base = url::Url::parse(base_path).unwrap();
22        let mut target_url = url::Url::parse(crate::apis::SVC_URL).unwrap();
23        let _ = target_url.set_scheme(base.scheme());
24        let _ = target_url.set_port(base.port());
25        let _ = target_url.set_host(Some(base.host_str().unwrap()));
26        format!("{target_url}")
27    } else {
28        crate::apis::SVC_URL.to_string()
29    }
30}
31
32
33/// struct for typed successes of method [`create_context`]
34#[derive(Debug, Clone, Serialize, Deserialize)]
35#[serde(untagged)]
36pub enum CreateContextSuccess {
37    Status200(models::ContextResponse),
38    UnknownValue(serde_json::Value),
39}
40
41/// struct for typed successes of method [`create_ingress`]
42#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(untagged)]
44pub enum CreateIngressSuccess {
45    Status200(models::IngressResponse),
46    UnknownValue(serde_json::Value),
47}
48
49/// struct for typed successes of method [`create_root_ingress`]
50#[derive(Debug, Clone, Serialize, Deserialize)]
51#[serde(untagged)]
52pub enum CreateRootIngressSuccess {
53    Status200(models::IngressResponse),
54    UnknownValue(serde_json::Value),
55}
56
57/// struct for typed successes of method [`create_support_request`]
58#[derive(Debug, Clone, Serialize, Deserialize)]
59#[serde(untagged)]
60pub enum CreateSupportRequestSuccess {
61    Status200(models::SupportCase),
62    UnknownValue(serde_json::Value),
63}
64
65/// struct for typed successes of method [`create_task`]
66#[derive(Debug, Clone, Serialize, Deserialize)]
67#[serde(untagged)]
68pub enum CreateTaskSuccess {
69    Status200(),
70    UnknownValue(serde_json::Value),
71}
72
73/// struct for typed successes of method [`delete_context`]
74#[derive(Debug, Clone, Serialize, Deserialize)]
75#[serde(untagged)]
76pub enum DeleteContextSuccess {
77    Status200(),
78    UnknownValue(serde_json::Value),
79}
80
81/// struct for typed successes of method [`delete_ingress`]
82#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum DeleteIngressSuccess {
85    Status200(),
86    UnknownValue(serde_json::Value),
87}
88
89/// struct for typed successes of method [`delete_root_ingress`]
90#[derive(Debug, Clone, Serialize, Deserialize)]
91#[serde(untagged)]
92pub enum DeleteRootIngressSuccess {
93    Status200(),
94    UnknownValue(serde_json::Value),
95}
96
97/// struct for typed successes of method [`enable_service`]
98#[derive(Debug, Clone, Serialize, Deserialize)]
99#[serde(untagged)]
100pub enum EnableServiceSuccess {
101    Status200(),
102    UnknownValue(serde_json::Value),
103}
104
105/// struct for typed successes of method [`get_context`]
106#[derive(Debug, Clone, Serialize, Deserialize)]
107#[serde(untagged)]
108pub enum GetContextSuccess {
109    Status200(models::ContextResponse),
110    UnknownValue(serde_json::Value),
111}
112
113/// struct for typed successes of method [`get_current_context`]
114#[derive(Debug, Clone, Serialize, Deserialize)]
115#[serde(untagged)]
116pub enum GetCurrentContextSuccess {
117    Status200(models::ContextResponse),
118    UnknownValue(serde_json::Value),
119}
120
121/// struct for typed successes of method [`get_ingress`]
122#[derive(Debug, Clone, Serialize, Deserialize)]
123#[serde(untagged)]
124pub enum GetIngressSuccess {
125    Status200(models::IngressResponse),
126    UnknownValue(serde_json::Value),
127}
128
129/// struct for typed successes of method [`get_root_ingress`]
130#[derive(Debug, Clone, Serialize, Deserialize)]
131#[serde(untagged)]
132pub enum GetRootIngressSuccess {
133    Status200(models::IngressResponse),
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed successes of method [`get_support_case`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum GetSupportCaseSuccess {
141    Status200(models::SupportCase),
142    UnknownValue(serde_json::Value),
143}
144
145/// struct for typed successes of method [`get_task_history`]
146#[derive(Debug, Clone, Serialize, Deserialize)]
147#[serde(untagged)]
148pub enum GetTaskHistorySuccess {
149    Status200(),
150    UnknownValue(serde_json::Value),
151}
152
153/// struct for typed successes of method [`issue_certificate`]
154#[derive(Debug, Clone, Serialize, Deserialize)]
155#[serde(untagged)]
156pub enum IssueCertificateSuccess {
157    Status200(),
158    UnknownValue(serde_json::Value),
159}
160
161/// struct for typed successes of method [`list_available_contexts`]
162#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(untagged)]
164pub enum ListAvailableContextsSuccess {
165    Status200(Vec<models::ContextResponse>),
166    UnknownValue(serde_json::Value),
167}
168
169/// struct for typed successes of method [`list_ingress`]
170#[derive(Debug, Clone, Serialize, Deserialize)]
171#[serde(untagged)]
172pub enum ListIngressSuccess {
173    Status200(Vec<models::IngressResponse>),
174    UnknownValue(serde_json::Value),
175}
176
177/// struct for typed successes of method [`list_support_cases`]
178#[derive(Debug, Clone, Serialize, Deserialize)]
179#[serde(untagged)]
180pub enum ListSupportCasesSuccess {
181    Status200(Vec<models::SupportCase>),
182    UnknownValue(serde_json::Value),
183}
184
185/// struct for typed successes of method [`pull_task_from_queue`]
186#[derive(Debug, Clone, Serialize, Deserialize)]
187#[serde(untagged)]
188pub enum PullTaskFromQueueSuccess {
189    Status200(models::PullTaskFromQueue200Response),
190    Status204(),
191    UnknownValue(serde_json::Value),
192}
193
194/// struct for typed successes of method [`update_context`]
195#[derive(Debug, Clone, Serialize, Deserialize)]
196#[serde(untagged)]
197pub enum UpdateContextSuccess {
198    Status200(models::ContextResponse),
199    UnknownValue(serde_json::Value),
200}
201
202/// struct for typed successes of method [`update_support_case`]
203#[derive(Debug, Clone, Serialize, Deserialize)]
204#[serde(untagged)]
205pub enum UpdateSupportCaseSuccess {
206    Status200(models::SupportCase),
207    UnknownValue(serde_json::Value),
208}
209
210/// struct for typed errors of method [`create_context`]
211#[derive(Debug, Clone, Serialize, Deserialize)]
212#[serde(untagged)]
213pub enum CreateContextError {
214    UnknownValue(serde_json::Value),
215}
216
217/// struct for typed errors of method [`create_ingress`]
218#[derive(Debug, Clone, Serialize, Deserialize)]
219#[serde(untagged)]
220pub enum CreateIngressError {
221    UnknownValue(serde_json::Value),
222}
223
224/// struct for typed errors of method [`create_root_ingress`]
225#[derive(Debug, Clone, Serialize, Deserialize)]
226#[serde(untagged)]
227pub enum CreateRootIngressError {
228    UnknownValue(serde_json::Value),
229}
230
231/// struct for typed errors of method [`create_support_request`]
232#[derive(Debug, Clone, Serialize, Deserialize)]
233#[serde(untagged)]
234pub enum CreateSupportRequestError {
235    UnknownValue(serde_json::Value),
236}
237
238/// struct for typed errors of method [`create_task`]
239#[derive(Debug, Clone, Serialize, Deserialize)]
240#[serde(untagged)]
241pub enum CreateTaskError {
242    UnknownValue(serde_json::Value),
243}
244
245/// struct for typed errors of method [`delete_context`]
246#[derive(Debug, Clone, Serialize, Deserialize)]
247#[serde(untagged)]
248pub enum DeleteContextError {
249    UnknownValue(serde_json::Value),
250}
251
252/// struct for typed errors of method [`delete_ingress`]
253#[derive(Debug, Clone, Serialize, Deserialize)]
254#[serde(untagged)]
255pub enum DeleteIngressError {
256    UnknownValue(serde_json::Value),
257}
258
259/// struct for typed errors of method [`delete_root_ingress`]
260#[derive(Debug, Clone, Serialize, Deserialize)]
261#[serde(untagged)]
262pub enum DeleteRootIngressError {
263    UnknownValue(serde_json::Value),
264}
265
266/// struct for typed errors of method [`enable_service`]
267#[derive(Debug, Clone, Serialize, Deserialize)]
268#[serde(untagged)]
269pub enum EnableServiceError {
270    UnknownValue(serde_json::Value),
271}
272
273/// struct for typed errors of method [`get_context`]
274#[derive(Debug, Clone, Serialize, Deserialize)]
275#[serde(untagged)]
276pub enum GetContextError {
277    UnknownValue(serde_json::Value),
278}
279
280/// struct for typed errors of method [`get_current_context`]
281#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(untagged)]
283pub enum GetCurrentContextError {
284    UnknownValue(serde_json::Value),
285}
286
287/// struct for typed errors of method [`get_ingress`]
288#[derive(Debug, Clone, Serialize, Deserialize)]
289#[serde(untagged)]
290pub enum GetIngressError {
291    UnknownValue(serde_json::Value),
292}
293
294/// struct for typed errors of method [`get_root_ingress`]
295#[derive(Debug, Clone, Serialize, Deserialize)]
296#[serde(untagged)]
297pub enum GetRootIngressError {
298    UnknownValue(serde_json::Value),
299}
300
301/// struct for typed errors of method [`get_support_case`]
302#[derive(Debug, Clone, Serialize, Deserialize)]
303#[serde(untagged)]
304pub enum GetSupportCaseError {
305    UnknownValue(serde_json::Value),
306}
307
308/// struct for typed errors of method [`get_task_history`]
309#[derive(Debug, Clone, Serialize, Deserialize)]
310#[serde(untagged)]
311pub enum GetTaskHistoryError {
312    UnknownValue(serde_json::Value),
313}
314
315/// struct for typed errors of method [`issue_certificate`]
316#[derive(Debug, Clone, Serialize, Deserialize)]
317#[serde(untagged)]
318pub enum IssueCertificateError {
319    Status429(),
320    UnknownValue(serde_json::Value),
321}
322
323/// struct for typed errors of method [`list_available_contexts`]
324#[derive(Debug, Clone, Serialize, Deserialize)]
325#[serde(untagged)]
326pub enum ListAvailableContextsError {
327    UnknownValue(serde_json::Value),
328}
329
330/// struct for typed errors of method [`list_ingress`]
331#[derive(Debug, Clone, Serialize, Deserialize)]
332#[serde(untagged)]
333pub enum ListIngressError {
334    UnknownValue(serde_json::Value),
335}
336
337/// struct for typed errors of method [`list_support_cases`]
338#[derive(Debug, Clone, Serialize, Deserialize)]
339#[serde(untagged)]
340pub enum ListSupportCasesError {
341    UnknownValue(serde_json::Value),
342}
343
344/// struct for typed errors of method [`pull_task_from_queue`]
345#[derive(Debug, Clone, Serialize, Deserialize)]
346#[serde(untagged)]
347pub enum PullTaskFromQueueError {
348    UnknownValue(serde_json::Value),
349}
350
351/// struct for typed errors of method [`update_context`]
352#[derive(Debug, Clone, Serialize, Deserialize)]
353#[serde(untagged)]
354pub enum UpdateContextError {
355    UnknownValue(serde_json::Value),
356}
357
358/// struct for typed errors of method [`update_support_case`]
359#[derive(Debug, Clone, Serialize, Deserialize)]
360#[serde(untagged)]
361pub enum UpdateSupportCaseError {
362    UnknownValue(serde_json::Value),
363}
364
365
366/// create new context
367pub async fn create_context(configuration: &Configuration, create_context_request: Option<models::CreateContextRequest>) -> Result<ResponseContent<CreateContextSuccess>, Error<CreateContextError>> {
368    // add a prefix to parameters to efficiently prevent name collisions
369    let p_create_context_request = create_context_request;
370
371    let uri_str = format!("{}/context", build_url(configuration));
372    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
373
374    if let Some(ref token) = configuration.oauth_access_token {
375        req_builder = req_builder.bearer_auth(token.to_owned());
376    };
377    if let Some(ref value) = configuration.api_key {
378        req_builder = req_builder.header("X-API-KEY", value);
379    };
380    req_builder = req_builder.json(&p_create_context_request);
381
382    let req = req_builder.build()?;
383    let resp = configuration.client.execute(req).await?;
384
385    let status = resp.status();
386
387    if !status.is_client_error() && !status.is_server_error() {
388        let content = resp.text().await?;
389        let entity: Option<CreateContextSuccess> = serde_json::from_str(&content).ok();
390        Ok(ResponseContent { status, content, entity })
391    } else {
392        let content = resp.text().await?;
393        let entity: Option<CreateContextError> = serde_json::from_str(&content).ok();
394        Err(Error::ResponseError(ResponseContent { status, content, entity }))
395    }
396}
397
398pub async fn create_ingress(configuration: &Configuration, domain: &str, uri: &str, create_ingress_request: Option<models::CreateIngressRequest>) -> Result<ResponseContent<CreateIngressSuccess>, Error<CreateIngressError>> {
399    // add a prefix to parameters to efficiently prevent name collisions
400    let p_domain = domain;
401    let p_uri = uri;
402    let p_create_ingress_request = create_ingress_request;
403
404    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_domain), uri=crate::apis::urlencode(p_uri));
405    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
406
407    if let Some(ref token) = configuration.oauth_access_token {
408        req_builder = req_builder.bearer_auth(token.to_owned());
409    };
410    if let Some(ref value) = configuration.api_key {
411        req_builder = req_builder.header("X-API-KEY", value);
412    };
413    req_builder = req_builder.json(&p_create_ingress_request);
414
415    let req = req_builder.build()?;
416    let resp = configuration.client.execute(req).await?;
417
418    let status = resp.status();
419
420    if !status.is_client_error() && !status.is_server_error() {
421        let content = resp.text().await?;
422        let entity: Option<CreateIngressSuccess> = serde_json::from_str(&content).ok();
423        Ok(ResponseContent { status, content, entity })
424    } else {
425        let content = resp.text().await?;
426        let entity: Option<CreateIngressError> = serde_json::from_str(&content).ok();
427        Err(Error::ResponseError(ResponseContent { status, content, entity }))
428    }
429}
430
431pub async fn create_root_ingress(configuration: &Configuration, domain: &str, create_ingress_request: Option<models::CreateIngressRequest>) -> Result<ResponseContent<CreateRootIngressSuccess>, Error<CreateRootIngressError>> {
432    // add a prefix to parameters to efficiently prevent name collisions
433    let p_domain = domain;
434    let p_create_ingress_request = create_ingress_request;
435
436    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_domain));
437    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
438
439    if let Some(ref token) = configuration.oauth_access_token {
440        req_builder = req_builder.bearer_auth(token.to_owned());
441    };
442    if let Some(ref value) = configuration.api_key {
443        req_builder = req_builder.header("X-API-KEY", value);
444    };
445    req_builder = req_builder.json(&p_create_ingress_request);
446
447    let req = req_builder.build()?;
448    let resp = configuration.client.execute(req).await?;
449
450    let status = resp.status();
451
452    if !status.is_client_error() && !status.is_server_error() {
453        let content = resp.text().await?;
454        let entity: Option<CreateRootIngressSuccess> = serde_json::from_str(&content).ok();
455        Ok(ResponseContent { status, content, entity })
456    } else {
457        let content = resp.text().await?;
458        let entity: Option<CreateRootIngressError> = serde_json::from_str(&content).ok();
459        Err(Error::ResponseError(ResponseContent { status, content, entity }))
460    }
461}
462
463pub async fn create_support_request(configuration: &Configuration, create_support_request_request: Option<models::CreateSupportRequestRequest>) -> Result<ResponseContent<CreateSupportRequestSuccess>, Error<CreateSupportRequestError>> {
464    // add a prefix to parameters to efficiently prevent name collisions
465    let p_create_support_request_request = create_support_request_request;
466
467    let uri_str = format!("{}/support", build_url(configuration));
468    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
469
470    if let Some(ref token) = configuration.oauth_access_token {
471        req_builder = req_builder.bearer_auth(token.to_owned());
472    };
473    if let Some(ref value) = configuration.api_key {
474        req_builder = req_builder.header("X-API-KEY", value);
475    };
476    req_builder = req_builder.json(&p_create_support_request_request);
477
478    let req = req_builder.build()?;
479    let resp = configuration.client.execute(req).await?;
480
481    let status = resp.status();
482
483    if !status.is_client_error() && !status.is_server_error() {
484        let content = resp.text().await?;
485        let entity: Option<CreateSupportRequestSuccess> = serde_json::from_str(&content).ok();
486        Ok(ResponseContent { status, content, entity })
487    } else {
488        let content = resp.text().await?;
489        let entity: Option<CreateSupportRequestError> = serde_json::from_str(&content).ok();
490        Err(Error::ResponseError(ResponseContent { status, content, entity }))
491    }
492}
493
494pub async fn create_task(configuration: &Configuration, task_id: &str, create_task_request: Option<models::CreateTaskRequest>) -> Result<ResponseContent<CreateTaskSuccess>, Error<CreateTaskError>> {
495    // add a prefix to parameters to efficiently prevent name collisions
496    let p_task_id = task_id;
497    let p_create_task_request = create_task_request;
498
499    let uri_str = format!("{}/task/{task_id}", build_url(configuration), task_id=crate::apis::urlencode(p_task_id));
500    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
501
502    if let Some(ref token) = configuration.oauth_access_token {
503        req_builder = req_builder.bearer_auth(token.to_owned());
504    };
505    if let Some(ref value) = configuration.api_key {
506        req_builder = req_builder.header("X-API-KEY", value);
507    };
508    req_builder = req_builder.json(&p_create_task_request);
509
510    let req = req_builder.build()?;
511    let resp = configuration.client.execute(req).await?;
512
513    let status = resp.status();
514
515    if !status.is_client_error() && !status.is_server_error() {
516        let content = resp.text().await?;
517        let entity: Option<CreateTaskSuccess> = serde_json::from_str(&content).ok();
518        Ok(ResponseContent { status, content, entity })
519    } else {
520        let content = resp.text().await?;
521        let entity: Option<CreateTaskError> = serde_json::from_str(&content).ok();
522        Err(Error::ResponseError(ResponseContent { status, content, entity }))
523    }
524}
525
526pub async fn delete_context(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<DeleteContextSuccess>, Error<DeleteContextError>> {
527    // add a prefix to parameters to efficiently prevent name collisions
528    let p_context_id = context_id;
529
530    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_context_id));
531    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
532
533    if let Some(ref token) = configuration.oauth_access_token {
534        req_builder = req_builder.bearer_auth(token.to_owned());
535    };
536    if let Some(ref value) = configuration.api_key {
537        req_builder = req_builder.header("X-API-KEY", value);
538    };
539
540    let req = req_builder.build()?;
541    let resp = configuration.client.execute(req).await?;
542
543    let status = resp.status();
544
545    if !status.is_client_error() && !status.is_server_error() {
546        let content = resp.text().await?;
547        let entity: Option<DeleteContextSuccess> = serde_json::from_str(&content).ok();
548        Ok(ResponseContent { status, content, entity })
549    } else {
550        let content = resp.text().await?;
551        let entity: Option<DeleteContextError> = serde_json::from_str(&content).ok();
552        Err(Error::ResponseError(ResponseContent { status, content, entity }))
553    }
554}
555
556pub async fn delete_ingress(configuration: &Configuration, domain: &str, uri: &str) -> Result<ResponseContent<DeleteIngressSuccess>, Error<DeleteIngressError>> {
557    // add a prefix to parameters to efficiently prevent name collisions
558    let p_domain = domain;
559    let p_uri = uri;
560
561    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_domain), uri=crate::apis::urlencode(p_uri));
562    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
563
564    if let Some(ref token) = configuration.oauth_access_token {
565        req_builder = req_builder.bearer_auth(token.to_owned());
566    };
567    if let Some(ref value) = configuration.api_key {
568        req_builder = req_builder.header("X-API-KEY", value);
569    };
570
571    let req = req_builder.build()?;
572    let resp = configuration.client.execute(req).await?;
573
574    let status = resp.status();
575
576    if !status.is_client_error() && !status.is_server_error() {
577        let content = resp.text().await?;
578        let entity: Option<DeleteIngressSuccess> = serde_json::from_str(&content).ok();
579        Ok(ResponseContent { status, content, entity })
580    } else {
581        let content = resp.text().await?;
582        let entity: Option<DeleteIngressError> = serde_json::from_str(&content).ok();
583        Err(Error::ResponseError(ResponseContent { status, content, entity }))
584    }
585}
586
587pub async fn delete_root_ingress(configuration: &Configuration, domain: &str) -> Result<ResponseContent<DeleteRootIngressSuccess>, Error<DeleteRootIngressError>> {
588    // add a prefix to parameters to efficiently prevent name collisions
589    let p_domain = domain;
590
591    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_domain));
592    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
593
594    if let Some(ref token) = configuration.oauth_access_token {
595        req_builder = req_builder.bearer_auth(token.to_owned());
596    };
597    if let Some(ref value) = configuration.api_key {
598        req_builder = req_builder.header("X-API-KEY", value);
599    };
600
601    let req = req_builder.build()?;
602    let resp = configuration.client.execute(req).await?;
603
604    let status = resp.status();
605
606    if !status.is_client_error() && !status.is_server_error() {
607        let content = resp.text().await?;
608        let entity: Option<DeleteRootIngressSuccess> = serde_json::from_str(&content).ok();
609        Ok(ResponseContent { status, content, entity })
610    } else {
611        let content = resp.text().await?;
612        let entity: Option<DeleteRootIngressError> = serde_json::from_str(&content).ok();
613        Err(Error::ResponseError(ResponseContent { status, content, entity }))
614    }
615}
616
617pub async fn enable_service(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<EnableServiceSuccess>, Error<EnableServiceError>> {
618    // add a prefix to parameters to efficiently prevent name collisions
619    let p_context_id = context_id;
620
621    let uri_str = format!("{}/context/{context_id}/enableService", build_url(configuration), context_id=crate::apis::urlencode(p_context_id));
622    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
623
624    if let Some(ref token) = configuration.oauth_access_token {
625        req_builder = req_builder.bearer_auth(token.to_owned());
626    };
627    if let Some(ref value) = configuration.api_key {
628        req_builder = req_builder.header("X-API-KEY", value);
629    };
630
631    let req = req_builder.build()?;
632    let resp = configuration.client.execute(req).await?;
633
634    let status = resp.status();
635
636    if !status.is_client_error() && !status.is_server_error() {
637        let content = resp.text().await?;
638        let entity: Option<EnableServiceSuccess> = serde_json::from_str(&content).ok();
639        Ok(ResponseContent { status, content, entity })
640    } else {
641        let content = resp.text().await?;
642        let entity: Option<EnableServiceError> = serde_json::from_str(&content).ok();
643        Err(Error::ResponseError(ResponseContent { status, content, entity }))
644    }
645}
646
647pub async fn get_context(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<GetContextSuccess>, Error<GetContextError>> {
648    // add a prefix to parameters to efficiently prevent name collisions
649    let p_context_id = context_id;
650
651    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_context_id));
652    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
653
654    if let Some(ref token) = configuration.oauth_access_token {
655        req_builder = req_builder.bearer_auth(token.to_owned());
656    };
657    if let Some(ref value) = configuration.api_key {
658        req_builder = req_builder.header("X-API-KEY", value);
659    };
660
661    let req = req_builder.build()?;
662    let resp = configuration.client.execute(req).await?;
663
664    let status = resp.status();
665
666    if !status.is_client_error() && !status.is_server_error() {
667        let content = resp.text().await?;
668        let entity: Option<GetContextSuccess> = serde_json::from_str(&content).ok();
669        Ok(ResponseContent { status, content, entity })
670    } else {
671        let content = resp.text().await?;
672        let entity: Option<GetContextError> = serde_json::from_str(&content).ok();
673        Err(Error::ResponseError(ResponseContent { status, content, entity }))
674    }
675}
676
677/// get current context
678pub async fn get_current_context(configuration: &Configuration, ) -> Result<ResponseContent<GetCurrentContextSuccess>, Error<GetCurrentContextError>> {
679
680    let uri_str = format!("{}/context", build_url(configuration));
681    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
682
683    if let Some(ref token) = configuration.oauth_access_token {
684        req_builder = req_builder.bearer_auth(token.to_owned());
685    };
686    if let Some(ref value) = configuration.api_key {
687        req_builder = req_builder.header("X-API-KEY", value);
688    };
689
690    let req = req_builder.build()?;
691    let resp = configuration.client.execute(req).await?;
692
693    let status = resp.status();
694
695    if !status.is_client_error() && !status.is_server_error() {
696        let content = resp.text().await?;
697        let entity: Option<GetCurrentContextSuccess> = serde_json::from_str(&content).ok();
698        Ok(ResponseContent { status, content, entity })
699    } else {
700        let content = resp.text().await?;
701        let entity: Option<GetCurrentContextError> = serde_json::from_str(&content).ok();
702        Err(Error::ResponseError(ResponseContent { status, content, entity }))
703    }
704}
705
706pub async fn get_ingress(configuration: &Configuration, domain: &str, uri: &str, scope: &str) -> Result<ResponseContent<GetIngressSuccess>, Error<GetIngressError>> {
707    // add a prefix to parameters to efficiently prevent name collisions
708    let p_domain = domain;
709    let p_uri = uri;
710    let p_scope = scope;
711
712    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_domain), uri=crate::apis::urlencode(p_uri));
713    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
714
715    req_builder = req_builder.query(&[("scope", &p_scope.to_string())]);
716    if let Some(ref token) = configuration.oauth_access_token {
717        req_builder = req_builder.bearer_auth(token.to_owned());
718    };
719    if let Some(ref value) = configuration.api_key {
720        req_builder = req_builder.header("X-API-KEY", value);
721    };
722
723    let req = req_builder.build()?;
724    let resp = configuration.client.execute(req).await?;
725
726    let status = resp.status();
727
728    if !status.is_client_error() && !status.is_server_error() {
729        let content = resp.text().await?;
730        let entity: Option<GetIngressSuccess> = serde_json::from_str(&content).ok();
731        Ok(ResponseContent { status, content, entity })
732    } else {
733        let content = resp.text().await?;
734        let entity: Option<GetIngressError> = serde_json::from_str(&content).ok();
735        Err(Error::ResponseError(ResponseContent { status, content, entity }))
736    }
737}
738
739pub async fn get_root_ingress(configuration: &Configuration, domain: &str, scope: &str) -> Result<ResponseContent<GetRootIngressSuccess>, Error<GetRootIngressError>> {
740    // add a prefix to parameters to efficiently prevent name collisions
741    let p_domain = domain;
742    let p_scope = scope;
743
744    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_domain));
745    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
746
747    req_builder = req_builder.query(&[("scope", &p_scope.to_string())]);
748    if let Some(ref token) = configuration.oauth_access_token {
749        req_builder = req_builder.bearer_auth(token.to_owned());
750    };
751    if let Some(ref value) = configuration.api_key {
752        req_builder = req_builder.header("X-API-KEY", value);
753    };
754
755    let req = req_builder.build()?;
756    let resp = configuration.client.execute(req).await?;
757
758    let status = resp.status();
759
760    if !status.is_client_error() && !status.is_server_error() {
761        let content = resp.text().await?;
762        let entity: Option<GetRootIngressSuccess> = serde_json::from_str(&content).ok();
763        Ok(ResponseContent { status, content, entity })
764    } else {
765        let content = resp.text().await?;
766        let entity: Option<GetRootIngressError> = serde_json::from_str(&content).ok();
767        Err(Error::ResponseError(ResponseContent { status, content, entity }))
768    }
769}
770
771pub async fn get_support_case(configuration: &Configuration, case_id: &str) -> Result<ResponseContent<GetSupportCaseSuccess>, Error<GetSupportCaseError>> {
772    // add a prefix to parameters to efficiently prevent name collisions
773    let p_case_id = case_id;
774
775    let uri_str = format!("{}/support/{case_id}", build_url(configuration), case_id=crate::apis::urlencode(p_case_id));
776    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
777
778    if let Some(ref token) = configuration.oauth_access_token {
779        req_builder = req_builder.bearer_auth(token.to_owned());
780    };
781    if let Some(ref value) = configuration.api_key {
782        req_builder = req_builder.header("X-API-KEY", value);
783    };
784
785    let req = req_builder.build()?;
786    let resp = configuration.client.execute(req).await?;
787
788    let status = resp.status();
789
790    if !status.is_client_error() && !status.is_server_error() {
791        let content = resp.text().await?;
792        let entity: Option<GetSupportCaseSuccess> = serde_json::from_str(&content).ok();
793        Ok(ResponseContent { status, content, entity })
794    } else {
795        let content = resp.text().await?;
796        let entity: Option<GetSupportCaseError> = serde_json::from_str(&content).ok();
797        Err(Error::ResponseError(ResponseContent { status, content, entity }))
798    }
799}
800
801pub async fn get_task_history(configuration: &Configuration, task_id: &str) -> Result<ResponseContent<GetTaskHistorySuccess>, Error<GetTaskHistoryError>> {
802    // add a prefix to parameters to efficiently prevent name collisions
803    let p_task_id = task_id;
804
805    let uri_str = format!("{}/task/{task_id}", build_url(configuration), task_id=crate::apis::urlencode(p_task_id));
806    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
807
808    if let Some(ref token) = configuration.oauth_access_token {
809        req_builder = req_builder.bearer_auth(token.to_owned());
810    };
811    if let Some(ref value) = configuration.api_key {
812        req_builder = req_builder.header("X-API-KEY", value);
813    };
814
815    let req = req_builder.build()?;
816    let resp = configuration.client.execute(req).await?;
817
818    let status = resp.status();
819
820    if !status.is_client_error() && !status.is_server_error() {
821        let content = resp.text().await?;
822        let entity: Option<GetTaskHistorySuccess> = serde_json::from_str(&content).ok();
823        Ok(ResponseContent { status, content, entity })
824    } else {
825        let content = resp.text().await?;
826        let entity: Option<GetTaskHistoryError> = serde_json::from_str(&content).ok();
827        Err(Error::ResponseError(ResponseContent { status, content, entity }))
828    }
829}
830
831/// issue a certificate -  if no certificate exists a new one is issued, if a certificate exists a new one will only be issued 3 days before its expiration 
832pub async fn issue_certificate(configuration: &Configuration, issue_certificate_request: Option<models::IssueCertificateRequest>) -> Result<ResponseContent<IssueCertificateSuccess>, Error<IssueCertificateError>> {
833    // add a prefix to parameters to efficiently prevent name collisions
834    let p_issue_certificate_request = issue_certificate_request;
835
836    let uri_str = format!("{}/certificate", build_url(configuration));
837    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
838
839    if let Some(ref token) = configuration.oauth_access_token {
840        req_builder = req_builder.bearer_auth(token.to_owned());
841    };
842    if let Some(ref value) = configuration.api_key {
843        req_builder = req_builder.header("X-API-KEY", value);
844    };
845    req_builder = req_builder.json(&p_issue_certificate_request);
846
847    let req = req_builder.build()?;
848    let resp = configuration.client.execute(req).await?;
849
850    let status = resp.status();
851
852    if !status.is_client_error() && !status.is_server_error() {
853        let content = resp.text().await?;
854        let entity: Option<IssueCertificateSuccess> = serde_json::from_str(&content).ok();
855        Ok(ResponseContent { status, content, entity })
856    } else {
857        let content = resp.text().await?;
858        let entity: Option<IssueCertificateError> = serde_json::from_str(&content).ok();
859        Err(Error::ResponseError(ResponseContent { status, content, entity }))
860    }
861}
862
863pub async fn list_available_contexts(configuration: &Configuration, ) -> Result<ResponseContent<ListAvailableContextsSuccess>, Error<ListAvailableContextsError>> {
864
865    let uri_str = format!("{}/identity/availableContexts", build_url(configuration));
866    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
867
868    if let Some(ref token) = configuration.oauth_access_token {
869        req_builder = req_builder.bearer_auth(token.to_owned());
870    };
871    if let Some(ref value) = configuration.api_key {
872        req_builder = req_builder.header("X-API-KEY", value);
873    };
874
875    let req = req_builder.build()?;
876    let resp = configuration.client.execute(req).await?;
877
878    let status = resp.status();
879
880    if !status.is_client_error() && !status.is_server_error() {
881        let content = resp.text().await?;
882        let entity: Option<ListAvailableContextsSuccess> = serde_json::from_str(&content).ok();
883        Ok(ResponseContent { status, content, entity })
884    } else {
885        let content = resp.text().await?;
886        let entity: Option<ListAvailableContextsError> = serde_json::from_str(&content).ok();
887        Err(Error::ResponseError(ResponseContent { status, content, entity }))
888    }
889}
890
891pub async fn list_ingress(configuration: &Configuration, scope: Option<&str>) -> Result<ResponseContent<ListIngressSuccess>, Error<ListIngressError>> {
892    // add a prefix to parameters to efficiently prevent name collisions
893    let p_scope = scope;
894
895    let uri_str = format!("{}/ingress", build_url(configuration));
896    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
897
898    if let Some(ref param_value) = p_scope {
899        req_builder = req_builder.query(&[("scope", &param_value.to_string())]);
900    }
901    if let Some(ref token) = configuration.oauth_access_token {
902        req_builder = req_builder.bearer_auth(token.to_owned());
903    };
904    if let Some(ref value) = configuration.api_key {
905        req_builder = req_builder.header("X-API-KEY", value);
906    };
907
908    let req = req_builder.build()?;
909    let resp = configuration.client.execute(req).await?;
910
911    let status = resp.status();
912
913    if !status.is_client_error() && !status.is_server_error() {
914        let content = resp.text().await?;
915        let entity: Option<ListIngressSuccess> = serde_json::from_str(&content).ok();
916        Ok(ResponseContent { status, content, entity })
917    } else {
918        let content = resp.text().await?;
919        let entity: Option<ListIngressError> = serde_json::from_str(&content).ok();
920        Err(Error::ResponseError(ResponseContent { status, content, entity }))
921    }
922}
923
924pub async fn list_support_cases(configuration: &Configuration, ) -> Result<ResponseContent<ListSupportCasesSuccess>, Error<ListSupportCasesError>> {
925
926    let uri_str = format!("{}/support", build_url(configuration));
927    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
928
929    if let Some(ref token) = configuration.oauth_access_token {
930        req_builder = req_builder.bearer_auth(token.to_owned());
931    };
932    if let Some(ref value) = configuration.api_key {
933        req_builder = req_builder.header("X-API-KEY", value);
934    };
935
936    let req = req_builder.build()?;
937    let resp = configuration.client.execute(req).await?;
938
939    let status = resp.status();
940
941    if !status.is_client_error() && !status.is_server_error() {
942        let content = resp.text().await?;
943        let entity: Option<ListSupportCasesSuccess> = serde_json::from_str(&content).ok();
944        Ok(ResponseContent { status, content, entity })
945    } else {
946        let content = resp.text().await?;
947        let entity: Option<ListSupportCasesError> = serde_json::from_str(&content).ok();
948        Err(Error::ResponseError(ResponseContent { status, content, entity }))
949    }
950}
951
952pub async fn pull_task_from_queue(configuration: &Configuration, pull_task_from_queue_request: Option<models::PullTaskFromQueueRequest>) -> Result<ResponseContent<PullTaskFromQueueSuccess>, Error<PullTaskFromQueueError>> {
953    // add a prefix to parameters to efficiently prevent name collisions
954    let p_pull_task_from_queue_request = pull_task_from_queue_request;
955
956    let uri_str = format!("{}/task", build_url(configuration));
957    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
958
959    if let Some(ref token) = configuration.oauth_access_token {
960        req_builder = req_builder.bearer_auth(token.to_owned());
961    };
962    if let Some(ref value) = configuration.api_key {
963        req_builder = req_builder.header("X-API-KEY", value);
964    };
965    req_builder = req_builder.json(&p_pull_task_from_queue_request);
966
967    let req = req_builder.build()?;
968    let resp = configuration.client.execute(req).await?;
969
970    let status = resp.status();
971
972    if !status.is_client_error() && !status.is_server_error() {
973        let content = resp.text().await?;
974        let entity: Option<PullTaskFromQueueSuccess> = serde_json::from_str(&content).ok();
975        Ok(ResponseContent { status, content, entity })
976    } else {
977        let content = resp.text().await?;
978        let entity: Option<PullTaskFromQueueError> = serde_json::from_str(&content).ok();
979        Err(Error::ResponseError(ResponseContent { status, content, entity }))
980    }
981}
982
983/// update context
984pub async fn update_context(configuration: &Configuration, context_id: &str, create_context_request: Option<models::CreateContextRequest>) -> Result<ResponseContent<UpdateContextSuccess>, Error<UpdateContextError>> {
985    // add a prefix to parameters to efficiently prevent name collisions
986    let p_context_id = context_id;
987    let p_create_context_request = create_context_request;
988
989    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_context_id));
990    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
991
992    if let Some(ref token) = configuration.oauth_access_token {
993        req_builder = req_builder.bearer_auth(token.to_owned());
994    };
995    if let Some(ref value) = configuration.api_key {
996        req_builder = req_builder.header("X-API-KEY", value);
997    };
998    req_builder = req_builder.json(&p_create_context_request);
999
1000    let req = req_builder.build()?;
1001    let resp = configuration.client.execute(req).await?;
1002
1003    let status = resp.status();
1004
1005    if !status.is_client_error() && !status.is_server_error() {
1006        let content = resp.text().await?;
1007        let entity: Option<UpdateContextSuccess> = serde_json::from_str(&content).ok();
1008        Ok(ResponseContent { status, content, entity })
1009    } else {
1010        let content = resp.text().await?;
1011        let entity: Option<UpdateContextError> = serde_json::from_str(&content).ok();
1012        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1013    }
1014}
1015
1016pub async fn update_support_case(configuration: &Configuration, case_id: &str, create_support_request_request: Option<models::CreateSupportRequestRequest>) -> Result<ResponseContent<UpdateSupportCaseSuccess>, Error<UpdateSupportCaseError>> {
1017    // add a prefix to parameters to efficiently prevent name collisions
1018    let p_case_id = case_id;
1019    let p_create_support_request_request = create_support_request_request;
1020
1021    let uri_str = format!("{}/support/{case_id}", build_url(configuration), case_id=crate::apis::urlencode(p_case_id));
1022    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1023
1024    if let Some(ref token) = configuration.oauth_access_token {
1025        req_builder = req_builder.bearer_auth(token.to_owned());
1026    };
1027    if let Some(ref value) = configuration.api_key {
1028        req_builder = req_builder.header("X-API-KEY", value);
1029    };
1030    req_builder = req_builder.json(&p_create_support_request_request);
1031
1032    let req = req_builder.build()?;
1033    let resp = configuration.client.execute(req).await?;
1034
1035    let status = resp.status();
1036
1037    if !status.is_client_error() && !status.is_server_error() {
1038        let content = resp.text().await?;
1039        let entity: Option<UpdateSupportCaseSuccess> = serde_json::from_str(&content).ok();
1040        Ok(ResponseContent { status, content, entity })
1041    } else {
1042        let content = resp.text().await?;
1043        let entity: Option<UpdateSupportCaseError> = serde_json::from_str(&content).ok();
1044        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1045    }
1046}
1047
dtz_core/apis/default_api.rs

dtz_core/apis/
default_api.rs
