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

dtz_core/apis/
default_api.rs
