dtz_core/apis/
default_api.rs

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

dtz_core/apis/
default_api.rs
