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

dtz_core/apis/
default_api.rs
