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/// struct for passing optional header parameters to the method [`create_ingress`]
33#[derive(Clone, Debug, Default)]
34pub struct CreateIngressHeaders {
35    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
36    pub x_dtz_realm: Option<String>,
37}
38/// struct for passing optional header parameters to the method [`create_root_ingress`]
39#[derive(Clone, Debug, Default)]
40pub struct CreateRootIngressHeaders {
41    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
42    pub x_dtz_realm: Option<String>,
43}
44/// struct for passing optional header parameters to the method [`delete_ingress`]
45#[derive(Clone, Debug, Default)]
46pub struct DeleteIngressHeaders {
47    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
48    pub x_dtz_realm: Option<String>,
49}
50/// struct for passing optional header parameters to the method [`delete_root_ingress`]
51#[derive(Clone, Debug, Default)]
52pub struct DeleteRootIngressHeaders {
53    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
54    pub x_dtz_realm: Option<String>,
55}
56/// struct for passing optional header parameters to the method [`get_ingress`]
57#[derive(Clone, Debug, Default)]
58pub struct GetIngressHeaders {
59    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
60    pub x_dtz_realm: Option<String>,
61}
62/// struct for passing optional header parameters to the method [`get_root_ingress`]
63#[derive(Clone, Debug, Default)]
64pub struct GetRootIngressHeaders {
65    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
66    pub x_dtz_realm: Option<String>,
67}
68/// struct for passing optional header parameters to the method [`list_ingress`]
69#[derive(Clone, Debug, Default)]
70pub struct ListIngressHeaders {
71    /// see docs https://downtozero.cloud/docs e.g. dtz-objectstore, dtz-containerregistry, dtz-containers
72    pub x_dtz_realm: Option<String>,
73}
74
75/// struct for typed successes of method [`create_chat`]
76#[derive(Debug, Clone, Serialize, Deserialize)]
77#[serde(untagged)]
78pub enum CreateChatSuccess {
79    Status200(models::ChatResponseMessage),
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed successes of method [`create_context`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum CreateContextSuccess {
87    Status200(models::ContextResponse),
88    UnknownValue(serde_json::Value),
89}
90
91/// struct for typed successes of method [`create_ingress`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum CreateIngressSuccess {
95    Status200(models::IngressResponse),
96    UnknownValue(serde_json::Value),
97}
98
99/// struct for typed successes of method [`create_root_ingress`]
100#[derive(Debug, Clone, Serialize, Deserialize)]
101#[serde(untagged)]
102pub enum CreateRootIngressSuccess {
103    Status200(models::IngressResponse),
104    UnknownValue(serde_json::Value),
105}
106
107/// struct for typed successes of method [`create_task`]
108#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(untagged)]
110pub enum CreateTaskSuccess {
111    Status200(models::CreateTask200Response),
112    UnknownValue(serde_json::Value),
113}
114
115/// struct for typed successes of method [`delete_context`]
116#[derive(Debug, Clone, Serialize, Deserialize)]
117#[serde(untagged)]
118pub enum DeleteContextSuccess {
119    Status200(),
120    UnknownValue(serde_json::Value),
121}
122
123/// struct for typed successes of method [`delete_ingress`]
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum DeleteIngressSuccess {
127    Status200(),
128    UnknownValue(serde_json::Value),
129}
130
131/// struct for typed successes of method [`delete_root_ingress`]
132#[derive(Debug, Clone, Serialize, Deserialize)]
133#[serde(untagged)]
134pub enum DeleteRootIngressSuccess {
135    Status200(),
136    UnknownValue(serde_json::Value),
137}
138
139/// struct for typed successes of method [`enable_service`]
140#[derive(Debug, Clone, Serialize, Deserialize)]
141#[serde(untagged)]
142pub enum EnableServiceSuccess {
143    Status200(),
144    UnknownValue(serde_json::Value),
145}
146
147/// struct for typed successes of method [`get_chat`]
148#[derive(Debug, Clone, Serialize, Deserialize)]
149#[serde(untagged)]
150pub enum GetChatSuccess {
151    Status200(models::Chat),
152    UnknownValue(serde_json::Value),
153}
154
155/// struct for typed successes of method [`get_context`]
156#[derive(Debug, Clone, Serialize, Deserialize)]
157#[serde(untagged)]
158pub enum GetContextSuccess {
159    Status200(models::ContextResponse),
160    UnknownValue(serde_json::Value),
161}
162
163/// struct for typed successes of method [`get_current_context`]
164#[derive(Debug, Clone, Serialize, Deserialize)]
165#[serde(untagged)]
166pub enum GetCurrentContextSuccess {
167    Status200(models::ContextResponse),
168    UnknownValue(serde_json::Value),
169}
170
171/// struct for typed successes of method [`get_ingress`]
172#[derive(Debug, Clone, Serialize, Deserialize)]
173#[serde(untagged)]
174pub enum GetIngressSuccess {
175    Status200(models::IngressResponse),
176    UnknownValue(serde_json::Value),
177}
178
179/// struct for typed successes of method [`get_root_ingress`]
180#[derive(Debug, Clone, Serialize, Deserialize)]
181#[serde(untagged)]
182pub enum GetRootIngressSuccess {
183    Status200(models::IngressResponse),
184    UnknownValue(serde_json::Value),
185}
186
187/// struct for typed successes of method [`get_task_history`]
188#[derive(Debug, Clone, Serialize, Deserialize)]
189#[serde(untagged)]
190pub enum GetTaskHistorySuccess {
191    Status200(),
192    UnknownValue(serde_json::Value),
193}
194
195/// struct for typed successes of method [`issue_certificate`]
196#[derive(Debug, Clone, Serialize, Deserialize)]
197#[serde(untagged)]
198pub enum IssueCertificateSuccess {
199    Status200(),
200    UnknownValue(serde_json::Value),
201}
202
203/// struct for typed successes of method [`list_available_contexts`]
204#[derive(Debug, Clone, Serialize, Deserialize)]
205#[serde(untagged)]
206pub enum ListAvailableContextsSuccess {
207    Status200(Vec<models::ContextResponse>),
208    UnknownValue(serde_json::Value),
209}
210
211/// struct for typed successes of method [`list_chat`]
212#[derive(Debug, Clone, Serialize, Deserialize)]
213#[serde(untagged)]
214pub enum ListChatSuccess {
215    Status200(Vec<models::ListChat200ResponseInner>),
216    UnknownValue(serde_json::Value),
217}
218
219/// struct for typed successes of method [`list_ingress`]
220#[derive(Debug, Clone, Serialize, Deserialize)]
221#[serde(untagged)]
222pub enum ListIngressSuccess {
223    Status200(Vec<models::IngressResponse>),
224    UnknownValue(serde_json::Value),
225}
226
227/// struct for typed successes of method [`pull_task_from_queue`]
228#[derive(Debug, Clone, Serialize, Deserialize)]
229#[serde(untagged)]
230pub enum PullTaskFromQueueSuccess {
231    Status200(models::PullTaskFromQueue200Response),
232    Status204(),
233    UnknownValue(serde_json::Value),
234}
235
236/// struct for typed successes of method [`update_chat`]
237#[derive(Debug, Clone, Serialize, Deserialize)]
238#[serde(untagged)]
239pub enum UpdateChatSuccess {
240    Status200(models::ChatResponseMessage),
241    UnknownValue(serde_json::Value),
242}
243
244/// struct for typed successes of method [`update_context`]
245#[derive(Debug, Clone, Serialize, Deserialize)]
246#[serde(untagged)]
247pub enum UpdateContextSuccess {
248    Status200(models::ContextResponse),
249    UnknownValue(serde_json::Value),
250}
251
252/// struct for typed errors of method [`create_chat`]
253#[derive(Debug, Clone, Serialize, Deserialize)]
254#[serde(untagged)]
255pub enum CreateChatError {
256    UnknownValue(serde_json::Value),
257}
258
259/// struct for typed errors of method [`create_context`]
260#[derive(Debug, Clone, Serialize, Deserialize)]
261#[serde(untagged)]
262pub enum CreateContextError {
263    UnknownValue(serde_json::Value),
264}
265
266/// struct for typed errors of method [`create_ingress`]
267#[derive(Debug, Clone, Serialize, Deserialize)]
268#[serde(untagged)]
269pub enum CreateIngressError {
270    UnknownValue(serde_json::Value),
271}
272
273/// struct for typed errors of method [`create_root_ingress`]
274#[derive(Debug, Clone, Serialize, Deserialize)]
275#[serde(untagged)]
276pub enum CreateRootIngressError {
277    UnknownValue(serde_json::Value),
278}
279
280/// struct for typed errors of method [`create_task`]
281#[derive(Debug, Clone, Serialize, Deserialize)]
282#[serde(untagged)]
283pub enum CreateTaskError {
284    UnknownValue(serde_json::Value),
285}
286
287/// struct for typed errors of method [`delete_context`]
288#[derive(Debug, Clone, Serialize, Deserialize)]
289#[serde(untagged)]
290pub enum DeleteContextError {
291    UnknownValue(serde_json::Value),
292}
293
294/// struct for typed errors of method [`delete_ingress`]
295#[derive(Debug, Clone, Serialize, Deserialize)]
296#[serde(untagged)]
297pub enum DeleteIngressError {
298    UnknownValue(serde_json::Value),
299}
300
301/// struct for typed errors of method [`delete_root_ingress`]
302#[derive(Debug, Clone, Serialize, Deserialize)]
303#[serde(untagged)]
304pub enum DeleteRootIngressError {
305    UnknownValue(serde_json::Value),
306}
307
308/// struct for typed errors of method [`enable_service`]
309#[derive(Debug, Clone, Serialize, Deserialize)]
310#[serde(untagged)]
311pub enum EnableServiceError {
312    UnknownValue(serde_json::Value),
313}
314
315/// struct for typed errors of method [`get_chat`]
316#[derive(Debug, Clone, Serialize, Deserialize)]
317#[serde(untagged)]
318pub enum GetChatError {
319    UnknownValue(serde_json::Value),
320}
321
322/// struct for typed errors of method [`get_context`]
323#[derive(Debug, Clone, Serialize, Deserialize)]
324#[serde(untagged)]
325pub enum GetContextError {
326    UnknownValue(serde_json::Value),
327}
328
329/// struct for typed errors of method [`get_current_context`]
330#[derive(Debug, Clone, Serialize, Deserialize)]
331#[serde(untagged)]
332pub enum GetCurrentContextError {
333    UnknownValue(serde_json::Value),
334}
335
336/// struct for typed errors of method [`get_ingress`]
337#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(untagged)]
339pub enum GetIngressError {
340    UnknownValue(serde_json::Value),
341}
342
343/// struct for typed errors of method [`get_root_ingress`]
344#[derive(Debug, Clone, Serialize, Deserialize)]
345#[serde(untagged)]
346pub enum GetRootIngressError {
347    UnknownValue(serde_json::Value),
348}
349
350/// struct for typed errors of method [`get_task_history`]
351#[derive(Debug, Clone, Serialize, Deserialize)]
352#[serde(untagged)]
353pub enum GetTaskHistoryError {
354    UnknownValue(serde_json::Value),
355}
356
357/// struct for typed errors of method [`issue_certificate`]
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(untagged)]
360pub enum IssueCertificateError {
361    Status429(),
362    UnknownValue(serde_json::Value),
363}
364
365/// struct for typed errors of method [`list_available_contexts`]
366#[derive(Debug, Clone, Serialize, Deserialize)]
367#[serde(untagged)]
368pub enum ListAvailableContextsError {
369    UnknownValue(serde_json::Value),
370}
371
372/// struct for typed errors of method [`list_chat`]
373#[derive(Debug, Clone, Serialize, Deserialize)]
374#[serde(untagged)]
375pub enum ListChatError {
376    UnknownValue(serde_json::Value),
377}
378
379/// struct for typed errors of method [`list_ingress`]
380#[derive(Debug, Clone, Serialize, Deserialize)]
381#[serde(untagged)]
382pub enum ListIngressError {
383    UnknownValue(serde_json::Value),
384}
385
386/// struct for typed errors of method [`pull_task_from_queue`]
387#[derive(Debug, Clone, Serialize, Deserialize)]
388#[serde(untagged)]
389pub enum PullTaskFromQueueError {
390    UnknownValue(serde_json::Value),
391}
392
393/// struct for typed errors of method [`update_chat`]
394#[derive(Debug, Clone, Serialize, Deserialize)]
395#[serde(untagged)]
396pub enum UpdateChatError {
397    UnknownValue(serde_json::Value),
398}
399
400/// struct for typed errors of method [`update_context`]
401#[derive(Debug, Clone, Serialize, Deserialize)]
402#[serde(untagged)]
403pub enum UpdateContextError {
404    UnknownValue(serde_json::Value),
405}
406
407
408pub async fn create_chat(configuration: &Configuration, create_chat_request: Option<models::CreateChatRequest>) -> Result<ResponseContent<CreateChatSuccess>, Error<CreateChatError>> {
409    // add a prefix to parameters to efficiently prevent name collisions
410    let p_body_create_chat_request = create_chat_request;
411
412    let uri_str = format!("{}/chat", build_url(configuration));
413    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
414
415
416    if let Some(ref token) = configuration.oauth_access_token {
417        req_builder = req_builder.bearer_auth(token.to_owned());
418    };
419    if let Some(ref value) = configuration.api_key {
420        req_builder = req_builder.header("X-API-KEY", value);
421    };
422    req_builder = req_builder.json(&p_body_create_chat_request);
423
424    let req = req_builder.build()?;
425    let resp = configuration.client.execute(req).await?;
426
427    let status = resp.status();
428
429    if !status.is_client_error() && !status.is_server_error() {
430        let content = resp.text().await?;
431        let entity: Option<CreateChatSuccess> = serde_json::from_str(&content).ok();
432        Ok(ResponseContent { status, content, entity })
433    } else {
434        let content = resp.text().await?;
435        let entity: Option<CreateChatError> = serde_json::from_str(&content).ok();
436        Err(Error::ResponseError(ResponseContent { status, content, entity }))
437    }
438}
439
440/// create new context
441pub async fn create_context(configuration: &Configuration, create_context_request: Option<models::CreateContextRequest>) -> Result<ResponseContent<CreateContextSuccess>, Error<CreateContextError>> {
442    // add a prefix to parameters to efficiently prevent name collisions
443    let p_body_create_context_request = create_context_request;
444
445    let uri_str = format!("{}/context", build_url(configuration));
446    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
447
448
449    if let Some(ref token) = configuration.oauth_access_token {
450        req_builder = req_builder.bearer_auth(token.to_owned());
451    };
452    if let Some(ref value) = configuration.api_key {
453        req_builder = req_builder.header("X-API-KEY", value);
454    };
455    req_builder = req_builder.json(&p_body_create_context_request);
456
457    let req = req_builder.build()?;
458    let resp = configuration.client.execute(req).await?;
459
460    let status = resp.status();
461
462    if !status.is_client_error() && !status.is_server_error() {
463        let content = resp.text().await?;
464        let entity: Option<CreateContextSuccess> = serde_json::from_str(&content).ok();
465        Ok(ResponseContent { status, content, entity })
466    } else {
467        let content = resp.text().await?;
468        let entity: Option<CreateContextError> = serde_json::from_str(&content).ok();
469        Err(Error::ResponseError(ResponseContent { status, content, entity }))
470    }
471}
472
473pub async fn create_ingress(configuration: &Configuration, domain: &str, uri: &str, create_ingress_request: Option<models::CreateIngressRequest>, headers: Option<CreateIngressHeaders>) -> Result<ResponseContent<CreateIngressSuccess>, Error<CreateIngressError>> {
474    // add a prefix to parameters to efficiently prevent name collisions
475    let p_path_domain = domain;
476    let p_path_uri = uri;
477    let p_body_create_ingress_request = create_ingress_request;
478
479    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_path_domain), uri=crate::apis::urlencode(p_path_uri));
480    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
481
482    // Apply optional headers from the headers struct
483    if let Some(h) = &headers {
484        if let Some(param_value) = h.x_dtz_realm.as_ref() {
485            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
486        }
487    }
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_body_create_ingress_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<CreateIngressSuccess> = serde_json::from_str(&content).ok();
505        Ok(ResponseContent { status, content, entity })
506    } else {
507        let content = resp.text().await?;
508        let entity: Option<CreateIngressError> = serde_json::from_str(&content).ok();
509        Err(Error::ResponseError(ResponseContent { status, content, entity }))
510    }
511}
512
513pub async fn create_root_ingress(configuration: &Configuration, domain: &str, create_ingress_request: Option<models::CreateIngressRequest>, headers: Option<CreateRootIngressHeaders>) -> Result<ResponseContent<CreateRootIngressSuccess>, Error<CreateRootIngressError>> {
514    // add a prefix to parameters to efficiently prevent name collisions
515    let p_path_domain = domain;
516    let p_body_create_ingress_request = create_ingress_request;
517
518    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_path_domain));
519    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
520
521    // Apply optional headers from the headers struct
522    if let Some(h) = &headers {
523        if let Some(param_value) = h.x_dtz_realm.as_ref() {
524            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
525        }
526    }
527
528    if let Some(ref token) = configuration.oauth_access_token {
529        req_builder = req_builder.bearer_auth(token.to_owned());
530    };
531    if let Some(ref value) = configuration.api_key {
532        req_builder = req_builder.header("X-API-KEY", value);
533    };
534    req_builder = req_builder.json(&p_body_create_ingress_request);
535
536    let req = req_builder.build()?;
537    let resp = configuration.client.execute(req).await?;
538
539    let status = resp.status();
540
541    if !status.is_client_error() && !status.is_server_error() {
542        let content = resp.text().await?;
543        let entity: Option<CreateRootIngressSuccess> = serde_json::from_str(&content).ok();
544        Ok(ResponseContent { status, content, entity })
545    } else {
546        let content = resp.text().await?;
547        let entity: Option<CreateRootIngressError> = serde_json::from_str(&content).ok();
548        Err(Error::ResponseError(ResponseContent { status, content, entity }))
549    }
550}
551
552pub async fn create_task(configuration: &Configuration, task_id: &str, create_task_request: Option<models::CreateTaskRequest>) -> Result<ResponseContent<CreateTaskSuccess>, Error<CreateTaskError>> {
553    // add a prefix to parameters to efficiently prevent name collisions
554    let p_path_task_id = task_id;
555    let p_body_create_task_request = create_task_request;
556
557    let uri_str = format!("{}/task/{task_id}", build_url(configuration), task_id=crate::apis::urlencode(p_path_task_id));
558    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
559
560
561    if let Some(ref token) = configuration.oauth_access_token {
562        req_builder = req_builder.bearer_auth(token.to_owned());
563    };
564    if let Some(ref value) = configuration.api_key {
565        req_builder = req_builder.header("X-API-KEY", value);
566    };
567    req_builder = req_builder.json(&p_body_create_task_request);
568
569    let req = req_builder.build()?;
570    let resp = configuration.client.execute(req).await?;
571
572    let status = resp.status();
573
574    if !status.is_client_error() && !status.is_server_error() {
575        let content = resp.text().await?;
576        let entity: Option<CreateTaskSuccess> = serde_json::from_str(&content).ok();
577        Ok(ResponseContent { status, content, entity })
578    } else {
579        let content = resp.text().await?;
580        let entity: Option<CreateTaskError> = serde_json::from_str(&content).ok();
581        Err(Error::ResponseError(ResponseContent { status, content, entity }))
582    }
583}
584
585pub async fn delete_context(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<DeleteContextSuccess>, Error<DeleteContextError>> {
586    // add a prefix to parameters to efficiently prevent name collisions
587    let p_path_context_id = context_id;
588
589    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_path_context_id));
590    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
591
592
593    if let Some(ref token) = configuration.oauth_access_token {
594        req_builder = req_builder.bearer_auth(token.to_owned());
595    };
596    if let Some(ref value) = configuration.api_key {
597        req_builder = req_builder.header("X-API-KEY", value);
598    };
599
600    let req = req_builder.build()?;
601    let resp = configuration.client.execute(req).await?;
602
603    let status = resp.status();
604
605    if !status.is_client_error() && !status.is_server_error() {
606        let content = resp.text().await?;
607        let entity: Option<DeleteContextSuccess> = serde_json::from_str(&content).ok();
608        Ok(ResponseContent { status, content, entity })
609    } else {
610        let content = resp.text().await?;
611        let entity: Option<DeleteContextError> = serde_json::from_str(&content).ok();
612        Err(Error::ResponseError(ResponseContent { status, content, entity }))
613    }
614}
615
616pub async fn delete_ingress(configuration: &Configuration, domain: &str, uri: &str, headers: Option<DeleteIngressHeaders>) -> Result<ResponseContent<DeleteIngressSuccess>, Error<DeleteIngressError>> {
617    // add a prefix to parameters to efficiently prevent name collisions
618    let p_path_domain = domain;
619    let p_path_uri = uri;
620
621    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_path_domain), uri=crate::apis::urlencode(p_path_uri));
622    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
623
624    // Apply optional headers from the headers struct
625    if let Some(h) = &headers {
626        if let Some(param_value) = h.x_dtz_realm.as_ref() {
627            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
628        }
629    }
630
631    if let Some(ref token) = configuration.oauth_access_token {
632        req_builder = req_builder.bearer_auth(token.to_owned());
633    };
634    if let Some(ref value) = configuration.api_key {
635        req_builder = req_builder.header("X-API-KEY", value);
636    };
637
638    let req = req_builder.build()?;
639    let resp = configuration.client.execute(req).await?;
640
641    let status = resp.status();
642
643    if !status.is_client_error() && !status.is_server_error() {
644        let content = resp.text().await?;
645        let entity: Option<DeleteIngressSuccess> = serde_json::from_str(&content).ok();
646        Ok(ResponseContent { status, content, entity })
647    } else {
648        let content = resp.text().await?;
649        let entity: Option<DeleteIngressError> = serde_json::from_str(&content).ok();
650        Err(Error::ResponseError(ResponseContent { status, content, entity }))
651    }
652}
653
654pub async fn delete_root_ingress(configuration: &Configuration, domain: &str, headers: Option<DeleteRootIngressHeaders>) -> Result<ResponseContent<DeleteRootIngressSuccess>, Error<DeleteRootIngressError>> {
655    // add a prefix to parameters to efficiently prevent name collisions
656    let p_path_domain = domain;
657
658    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_path_domain));
659    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
660
661    // Apply optional headers from the headers struct
662    if let Some(h) = &headers {
663        if let Some(param_value) = h.x_dtz_realm.as_ref() {
664            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
665        }
666    }
667
668    if let Some(ref token) = configuration.oauth_access_token {
669        req_builder = req_builder.bearer_auth(token.to_owned());
670    };
671    if let Some(ref value) = configuration.api_key {
672        req_builder = req_builder.header("X-API-KEY", value);
673    };
674
675    let req = req_builder.build()?;
676    let resp = configuration.client.execute(req).await?;
677
678    let status = resp.status();
679
680    if !status.is_client_error() && !status.is_server_error() {
681        let content = resp.text().await?;
682        let entity: Option<DeleteRootIngressSuccess> = serde_json::from_str(&content).ok();
683        Ok(ResponseContent { status, content, entity })
684    } else {
685        let content = resp.text().await?;
686        let entity: Option<DeleteRootIngressError> = serde_json::from_str(&content).ok();
687        Err(Error::ResponseError(ResponseContent { status, content, entity }))
688    }
689}
690
691pub async fn enable_service(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<EnableServiceSuccess>, Error<EnableServiceError>> {
692    // add a prefix to parameters to efficiently prevent name collisions
693    let p_path_context_id = context_id;
694
695    let uri_str = format!("{}/context/{context_id}/enableService", build_url(configuration), context_id=crate::apis::urlencode(p_path_context_id));
696    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
697
698
699    if let Some(ref token) = configuration.oauth_access_token {
700        req_builder = req_builder.bearer_auth(token.to_owned());
701    };
702    if let Some(ref value) = configuration.api_key {
703        req_builder = req_builder.header("X-API-KEY", value);
704    };
705
706    let req = req_builder.build()?;
707    let resp = configuration.client.execute(req).await?;
708
709    let status = resp.status();
710
711    if !status.is_client_error() && !status.is_server_error() {
712        let content = resp.text().await?;
713        let entity: Option<EnableServiceSuccess> = serde_json::from_str(&content).ok();
714        Ok(ResponseContent { status, content, entity })
715    } else {
716        let content = resp.text().await?;
717        let entity: Option<EnableServiceError> = serde_json::from_str(&content).ok();
718        Err(Error::ResponseError(ResponseContent { status, content, entity }))
719    }
720}
721
722pub async fn get_chat(configuration: &Configuration, chat_id: &str) -> Result<ResponseContent<GetChatSuccess>, Error<GetChatError>> {
723    // add a prefix to parameters to efficiently prevent name collisions
724    let p_path_chat_id = chat_id;
725
726    let uri_str = format!("{}/chat/{chat_id}", build_url(configuration), chat_id=crate::apis::urlencode(p_path_chat_id));
727    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
728
729
730    if let Some(ref token) = configuration.oauth_access_token {
731        req_builder = req_builder.bearer_auth(token.to_owned());
732    };
733    if let Some(ref value) = configuration.api_key {
734        req_builder = req_builder.header("X-API-KEY", value);
735    };
736
737    let req = req_builder.build()?;
738    let resp = configuration.client.execute(req).await?;
739
740    let status = resp.status();
741
742    if !status.is_client_error() && !status.is_server_error() {
743        let content = resp.text().await?;
744        let entity: Option<GetChatSuccess> = serde_json::from_str(&content).ok();
745        Ok(ResponseContent { status, content, entity })
746    } else {
747        let content = resp.text().await?;
748        let entity: Option<GetChatError> = serde_json::from_str(&content).ok();
749        Err(Error::ResponseError(ResponseContent { status, content, entity }))
750    }
751}
752
753pub async fn get_context(configuration: &Configuration, context_id: &str) -> Result<ResponseContent<GetContextSuccess>, Error<GetContextError>> {
754    // add a prefix to parameters to efficiently prevent name collisions
755    let p_path_context_id = context_id;
756
757    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_path_context_id));
758    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
759
760
761    if let Some(ref token) = configuration.oauth_access_token {
762        req_builder = req_builder.bearer_auth(token.to_owned());
763    };
764    if let Some(ref value) = configuration.api_key {
765        req_builder = req_builder.header("X-API-KEY", value);
766    };
767
768    let req = req_builder.build()?;
769    let resp = configuration.client.execute(req).await?;
770
771    let status = resp.status();
772
773    if !status.is_client_error() && !status.is_server_error() {
774        let content = resp.text().await?;
775        let entity: Option<GetContextSuccess> = serde_json::from_str(&content).ok();
776        Ok(ResponseContent { status, content, entity })
777    } else {
778        let content = resp.text().await?;
779        let entity: Option<GetContextError> = serde_json::from_str(&content).ok();
780        Err(Error::ResponseError(ResponseContent { status, content, entity }))
781    }
782}
783
784/// get current context
785pub async fn get_current_context(configuration: &Configuration) -> Result<ResponseContent<GetCurrentContextSuccess>, Error<GetCurrentContextError>> {
786
787    let uri_str = format!("{}/context", build_url(configuration));
788    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
789
790
791    if let Some(ref token) = configuration.oauth_access_token {
792        req_builder = req_builder.bearer_auth(token.to_owned());
793    };
794    if let Some(ref value) = configuration.api_key {
795        req_builder = req_builder.header("X-API-KEY", value);
796    };
797
798    let req = req_builder.build()?;
799    let resp = configuration.client.execute(req).await?;
800
801    let status = resp.status();
802
803    if !status.is_client_error() && !status.is_server_error() {
804        let content = resp.text().await?;
805        let entity: Option<GetCurrentContextSuccess> = serde_json::from_str(&content).ok();
806        Ok(ResponseContent { status, content, entity })
807    } else {
808        let content = resp.text().await?;
809        let entity: Option<GetCurrentContextError> = serde_json::from_str(&content).ok();
810        Err(Error::ResponseError(ResponseContent { status, content, entity }))
811    }
812}
813
814pub async fn get_ingress(configuration: &Configuration, domain: &str, uri: &str, headers: Option<GetIngressHeaders>) -> Result<ResponseContent<GetIngressSuccess>, Error<GetIngressError>> {
815    // add a prefix to parameters to efficiently prevent name collisions
816    let p_path_domain = domain;
817    let p_path_uri = uri;
818
819    let uri_str = format!("{}/ingress/{domain}/{uri}", build_url(configuration), domain=crate::apis::urlencode(p_path_domain), uri=crate::apis::urlencode(p_path_uri));
820    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
821
822    // Apply optional headers from the headers struct
823    if let Some(h) = &headers {
824        if let Some(param_value) = h.x_dtz_realm.as_ref() {
825            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
826        }
827    }
828
829    if let Some(ref token) = configuration.oauth_access_token {
830        req_builder = req_builder.bearer_auth(token.to_owned());
831    };
832    if let Some(ref value) = configuration.api_key {
833        req_builder = req_builder.header("X-API-KEY", value);
834    };
835
836    let req = req_builder.build()?;
837    let resp = configuration.client.execute(req).await?;
838
839    let status = resp.status();
840
841    if !status.is_client_error() && !status.is_server_error() {
842        let content = resp.text().await?;
843        let entity: Option<GetIngressSuccess> = serde_json::from_str(&content).ok();
844        Ok(ResponseContent { status, content, entity })
845    } else {
846        let content = resp.text().await?;
847        let entity: Option<GetIngressError> = serde_json::from_str(&content).ok();
848        Err(Error::ResponseError(ResponseContent { status, content, entity }))
849    }
850}
851
852pub async fn get_root_ingress(configuration: &Configuration, domain: &str, headers: Option<GetRootIngressHeaders>) -> Result<ResponseContent<GetRootIngressSuccess>, Error<GetRootIngressError>> {
853    // add a prefix to parameters to efficiently prevent name collisions
854    let p_path_domain = domain;
855
856    let uri_str = format!("{}/ingress/{domain}/", build_url(configuration), domain=crate::apis::urlencode(p_path_domain));
857    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
858
859    // Apply optional headers from the headers struct
860    if let Some(h) = &headers {
861        if let Some(param_value) = h.x_dtz_realm.as_ref() {
862            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
863        }
864    }
865
866    if let Some(ref token) = configuration.oauth_access_token {
867        req_builder = req_builder.bearer_auth(token.to_owned());
868    };
869    if let Some(ref value) = configuration.api_key {
870        req_builder = req_builder.header("X-API-KEY", value);
871    };
872
873    let req = req_builder.build()?;
874    let resp = configuration.client.execute(req).await?;
875
876    let status = resp.status();
877
878    if !status.is_client_error() && !status.is_server_error() {
879        let content = resp.text().await?;
880        let entity: Option<GetRootIngressSuccess> = serde_json::from_str(&content).ok();
881        Ok(ResponseContent { status, content, entity })
882    } else {
883        let content = resp.text().await?;
884        let entity: Option<GetRootIngressError> = serde_json::from_str(&content).ok();
885        Err(Error::ResponseError(ResponseContent { status, content, entity }))
886    }
887}
888
889pub async fn get_task_history(configuration: &Configuration, task_id: &str) -> Result<ResponseContent<GetTaskHistorySuccess>, Error<GetTaskHistoryError>> {
890    // add a prefix to parameters to efficiently prevent name collisions
891    let p_path_task_id = task_id;
892
893    let uri_str = format!("{}/task/{task_id}", build_url(configuration), task_id=crate::apis::urlencode(p_path_task_id));
894    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
895
896
897    if let Some(ref token) = configuration.oauth_access_token {
898        req_builder = req_builder.bearer_auth(token.to_owned());
899    };
900    if let Some(ref value) = configuration.api_key {
901        req_builder = req_builder.header("X-API-KEY", value);
902    };
903
904    let req = req_builder.build()?;
905    let resp = configuration.client.execute(req).await?;
906
907    let status = resp.status();
908
909    if !status.is_client_error() && !status.is_server_error() {
910        let content = resp.text().await?;
911        let entity: Option<GetTaskHistorySuccess> = serde_json::from_str(&content).ok();
912        Ok(ResponseContent { status, content, entity })
913    } else {
914        let content = resp.text().await?;
915        let entity: Option<GetTaskHistoryError> = serde_json::from_str(&content).ok();
916        Err(Error::ResponseError(ResponseContent { status, content, entity }))
917    }
918}
919
920/// 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 
921pub async fn issue_certificate(configuration: &Configuration, issue_certificate_request: Option<models::IssueCertificateRequest>) -> Result<ResponseContent<IssueCertificateSuccess>, Error<IssueCertificateError>> {
922    // add a prefix to parameters to efficiently prevent name collisions
923    let p_body_issue_certificate_request = issue_certificate_request;
924
925    let uri_str = format!("{}/certificate", build_url(configuration));
926    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
927
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    req_builder = req_builder.json(&p_body_issue_certificate_request);
936
937    let req = req_builder.build()?;
938    let resp = configuration.client.execute(req).await?;
939
940    let status = resp.status();
941
942    if !status.is_client_error() && !status.is_server_error() {
943        let content = resp.text().await?;
944        let entity: Option<IssueCertificateSuccess> = serde_json::from_str(&content).ok();
945        Ok(ResponseContent { status, content, entity })
946    } else {
947        let content = resp.text().await?;
948        let entity: Option<IssueCertificateError> = serde_json::from_str(&content).ok();
949        Err(Error::ResponseError(ResponseContent { status, content, entity }))
950    }
951}
952
953pub async fn list_available_contexts(configuration: &Configuration) -> Result<ResponseContent<ListAvailableContextsSuccess>, Error<ListAvailableContextsError>> {
954
955    let uri_str = format!("{}/identity/availableContexts", build_url(configuration));
956    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
957
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
966    let req = req_builder.build()?;
967    let resp = configuration.client.execute(req).await?;
968
969    let status = resp.status();
970
971    if !status.is_client_error() && !status.is_server_error() {
972        let content = resp.text().await?;
973        let entity: Option<ListAvailableContextsSuccess> = serde_json::from_str(&content).ok();
974        Ok(ResponseContent { status, content, entity })
975    } else {
976        let content = resp.text().await?;
977        let entity: Option<ListAvailableContextsError> = serde_json::from_str(&content).ok();
978        Err(Error::ResponseError(ResponseContent { status, content, entity }))
979    }
980}
981
982pub async fn list_chat(configuration: &Configuration) -> Result<ResponseContent<ListChatSuccess>, Error<ListChatError>> {
983
984    let uri_str = format!("{}/chat", build_url(configuration));
985    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
986
987
988    if let Some(ref token) = configuration.oauth_access_token {
989        req_builder = req_builder.bearer_auth(token.to_owned());
990    };
991    if let Some(ref value) = configuration.api_key {
992        req_builder = req_builder.header("X-API-KEY", value);
993    };
994
995    let req = req_builder.build()?;
996    let resp = configuration.client.execute(req).await?;
997
998    let status = resp.status();
999
1000    if !status.is_client_error() && !status.is_server_error() {
1001        let content = resp.text().await?;
1002        let entity: Option<ListChatSuccess> = serde_json::from_str(&content).ok();
1003        Ok(ResponseContent { status, content, entity })
1004    } else {
1005        let content = resp.text().await?;
1006        let entity: Option<ListChatError> = serde_json::from_str(&content).ok();
1007        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1008    }
1009}
1010
1011pub async fn list_ingress(configuration: &Configuration, headers: Option<ListIngressHeaders>) -> Result<ResponseContent<ListIngressSuccess>, Error<ListIngressError>> {
1012    // add a prefix to parameters to efficiently prevent name collisions
1013
1014    let uri_str = format!("{}/ingress", build_url(configuration));
1015    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
1016
1017    // Apply optional headers from the headers struct
1018    if let Some(h) = &headers {
1019        if let Some(param_value) = h.x_dtz_realm.as_ref() {
1020            req_builder = req_builder.header("X-DTZ-REALM", param_value.to_string());
1021        }
1022    }
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
1031    let req = req_builder.build()?;
1032    let resp = configuration.client.execute(req).await?;
1033
1034    let status = resp.status();
1035
1036    if !status.is_client_error() && !status.is_server_error() {
1037        let content = resp.text().await?;
1038        let entity: Option<ListIngressSuccess> = serde_json::from_str(&content).ok();
1039        Ok(ResponseContent { status, content, entity })
1040    } else {
1041        let content = resp.text().await?;
1042        let entity: Option<ListIngressError> = serde_json::from_str(&content).ok();
1043        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1044    }
1045}
1046
1047pub async fn pull_task_from_queue(configuration: &Configuration, pull_task_from_queue_request: Option<models::PullTaskFromQueueRequest>) -> Result<ResponseContent<PullTaskFromQueueSuccess>, Error<PullTaskFromQueueError>> {
1048    // add a prefix to parameters to efficiently prevent name collisions
1049    let p_body_pull_task_from_queue_request = pull_task_from_queue_request;
1050
1051    let uri_str = format!("{}/task", build_url(configuration));
1052    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1053
1054
1055    if let Some(ref token) = configuration.oauth_access_token {
1056        req_builder = req_builder.bearer_auth(token.to_owned());
1057    };
1058    if let Some(ref value) = configuration.api_key {
1059        req_builder = req_builder.header("X-API-KEY", value);
1060    };
1061    req_builder = req_builder.json(&p_body_pull_task_from_queue_request);
1062
1063    let req = req_builder.build()?;
1064    let resp = configuration.client.execute(req).await?;
1065
1066    let status = resp.status();
1067
1068    if !status.is_client_error() && !status.is_server_error() {
1069        let content = resp.text().await?;
1070        let entity: Option<PullTaskFromQueueSuccess> = serde_json::from_str(&content).ok();
1071        Ok(ResponseContent { status, content, entity })
1072    } else {
1073        let content = resp.text().await?;
1074        let entity: Option<PullTaskFromQueueError> = serde_json::from_str(&content).ok();
1075        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1076    }
1077}
1078
1079pub async fn update_chat(configuration: &Configuration, chat_id: &str, create_chat_request: Option<models::CreateChatRequest>) -> Result<ResponseContent<UpdateChatSuccess>, Error<UpdateChatError>> {
1080    // add a prefix to parameters to efficiently prevent name collisions
1081    let p_path_chat_id = chat_id;
1082    let p_body_create_chat_request = create_chat_request;
1083
1084    let uri_str = format!("{}/chat/{chat_id}", build_url(configuration), chat_id=crate::apis::urlencode(p_path_chat_id));
1085    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1086
1087
1088    if let Some(ref token) = configuration.oauth_access_token {
1089        req_builder = req_builder.bearer_auth(token.to_owned());
1090    };
1091    if let Some(ref value) = configuration.api_key {
1092        req_builder = req_builder.header("X-API-KEY", value);
1093    };
1094    req_builder = req_builder.json(&p_body_create_chat_request);
1095
1096    let req = req_builder.build()?;
1097    let resp = configuration.client.execute(req).await?;
1098
1099    let status = resp.status();
1100
1101    if !status.is_client_error() && !status.is_server_error() {
1102        let content = resp.text().await?;
1103        let entity: Option<UpdateChatSuccess> = serde_json::from_str(&content).ok();
1104        Ok(ResponseContent { status, content, entity })
1105    } else {
1106        let content = resp.text().await?;
1107        let entity: Option<UpdateChatError> = serde_json::from_str(&content).ok();
1108        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1109    }
1110}
1111
1112/// update context
1113pub async fn update_context(configuration: &Configuration, context_id: &str, create_context_request: Option<models::CreateContextRequest>) -> Result<ResponseContent<UpdateContextSuccess>, Error<UpdateContextError>> {
1114    // add a prefix to parameters to efficiently prevent name collisions
1115    let p_path_context_id = context_id;
1116    let p_body_create_context_request = create_context_request;
1117
1118    let uri_str = format!("{}/context/{context_id}", build_url(configuration), context_id=crate::apis::urlencode(p_path_context_id));
1119    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
1120
1121
1122    if let Some(ref token) = configuration.oauth_access_token {
1123        req_builder = req_builder.bearer_auth(token.to_owned());
1124    };
1125    if let Some(ref value) = configuration.api_key {
1126        req_builder = req_builder.header("X-API-KEY", value);
1127    };
1128    req_builder = req_builder.json(&p_body_create_context_request);
1129
1130    let req = req_builder.build()?;
1131    let resp = configuration.client.execute(req).await?;
1132
1133    let status = resp.status();
1134
1135    if !status.is_client_error() && !status.is_server_error() {
1136        let content = resp.text().await?;
1137        let entity: Option<UpdateContextSuccess> = serde_json::from_str(&content).ok();
1138        Ok(ResponseContent { status, content, entity })
1139    } else {
1140        let content = resp.text().await?;
1141        let entity: Option<UpdateContextError> = serde_json::from_str(&content).ok();
1142        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1143    }
1144}
1145
dtz_core/apis/default_api.rs

dtz_core/apis/
default_api.rs
