geoengine_api_client/apis/
layers_api.rs

1/*
2 * Geo Engine API
3 *
4 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
5 *
6 * The version of the OpenAPI document: 0.9.0
7 * Contact: dev@geoengine.de
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13use serde::{Deserialize, Serialize, de::Error as _};
14use crate::{apis::ResponseContent, models};
15use super::{Error, configuration, ContentType};
16
17
18/// struct for typed errors of method [`add_collection`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum AddCollectionError {
22    UnknownValue(serde_json::Value),
23}
24
25/// struct for typed errors of method [`add_existing_collection_to_collection`]
26#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum AddExistingCollectionToCollectionError {
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`add_existing_layer_to_collection`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum AddExistingLayerToCollectionError {
36    UnknownValue(serde_json::Value),
37}
38
39/// struct for typed errors of method [`add_layer`]
40#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum AddLayerError {
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`add_provider`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum AddProviderError {
50    UnknownValue(serde_json::Value),
51}
52
53/// struct for typed errors of method [`autocomplete_handler`]
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum AutocompleteHandlerError {
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`delete_provider`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum DeleteProviderError {
64    UnknownValue(serde_json::Value),
65}
66
67/// struct for typed errors of method [`get_provider_definition`]
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum GetProviderDefinitionError {
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`layer_handler`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum LayerHandlerError {
78    UnknownValue(serde_json::Value),
79}
80
81/// struct for typed errors of method [`layer_to_dataset`]
82#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum LayerToDatasetError {
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`layer_to_workflow_id_handler`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum LayerToWorkflowIdHandlerError {
92    UnknownValue(serde_json::Value),
93}
94
95/// struct for typed errors of method [`list_collection_handler`]
96#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum ListCollectionHandlerError {
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`list_providers`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum ListProvidersError {
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method [`list_root_collections_handler`]
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum ListRootCollectionsHandlerError {
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`provider_capabilities_handler`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum ProviderCapabilitiesHandlerError {
120    UnknownValue(serde_json::Value),
121}
122
123/// struct for typed errors of method [`remove_collection`]
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum RemoveCollectionError {
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`remove_collection_from_collection`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum RemoveCollectionFromCollectionError {
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed errors of method [`remove_layer`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum RemoveLayerError {
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`remove_layer_from_collection`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum RemoveLayerFromCollectionError {
148    UnknownValue(serde_json::Value),
149}
150
151/// struct for typed errors of method [`search_handler`]
152#[derive(Debug, Clone, Serialize, Deserialize)]
153#[serde(untagged)]
154pub enum SearchHandlerError {
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`update_collection`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum UpdateCollectionError {
162    UnknownValue(serde_json::Value),
163}
164
165/// struct for typed errors of method [`update_layer`]
166#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(untagged)]
168pub enum UpdateLayerError {
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`update_provider_definition`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum UpdateProviderDefinitionError {
176    UnknownValue(serde_json::Value),
177}
178
179
180pub async fn add_collection(configuration: &configuration::Configuration, collection: &str, add_layer_collection: models::AddLayerCollection) -> Result<models::IdResponse, Error<AddCollectionError>> {
181    // add a prefix to parameters to efficiently prevent name collisions
182    let p_path_collection = collection;
183    let p_body_add_layer_collection = add_layer_collection;
184
185    let uri_str = format!("{}/layerDb/collections/{collection}/collections", configuration.base_path, collection=crate::apis::urlencode(p_path_collection));
186    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
187
188    if let Some(ref user_agent) = configuration.user_agent {
189        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
190    }
191    if let Some(ref token) = configuration.bearer_access_token {
192        req_builder = req_builder.bearer_auth(token.to_owned());
193    };
194    req_builder = req_builder.json(&p_body_add_layer_collection);
195
196    let req = req_builder.build()?;
197    let resp = configuration.client.execute(req).await?;
198
199    let status = resp.status();
200    let content_type = resp
201        .headers()
202        .get("content-type")
203        .and_then(|v| v.to_str().ok())
204        .unwrap_or("application/octet-stream");
205    let content_type = super::ContentType::from(content_type);
206
207    if !status.is_client_error() && !status.is_server_error() {
208        let content = resp.text().await?;
209        match content_type {
210            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
211            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::IdResponse`"))),
212            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IdResponse`")))),
213        }
214    } else {
215        let content = resp.text().await?;
216        let entity: Option<AddCollectionError> = serde_json::from_str(&content).ok();
217        Err(Error::ResponseError(ResponseContent { status, content, entity }))
218    }
219}
220
221pub async fn add_existing_collection_to_collection(configuration: &configuration::Configuration, parent: &str, collection: &str) -> Result<(), Error<AddExistingCollectionToCollectionError>> {
222    // add a prefix to parameters to efficiently prevent name collisions
223    let p_path_parent = parent;
224    let p_path_collection = collection;
225
226    let uri_str = format!("{}/layerDb/collections/{parent}/collections/{collection}", configuration.base_path, parent=crate::apis::urlencode(p_path_parent), collection=crate::apis::urlencode(p_path_collection));
227    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
228
229    if let Some(ref user_agent) = configuration.user_agent {
230        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
231    }
232    if let Some(ref token) = configuration.bearer_access_token {
233        req_builder = req_builder.bearer_auth(token.to_owned());
234    };
235
236    let req = req_builder.build()?;
237    let resp = configuration.client.execute(req).await?;
238
239    let status = resp.status();
240
241    if !status.is_client_error() && !status.is_server_error() {
242        Ok(())
243    } else {
244        let content = resp.text().await?;
245        let entity: Option<AddExistingCollectionToCollectionError> = serde_json::from_str(&content).ok();
246        Err(Error::ResponseError(ResponseContent { status, content, entity }))
247    }
248}
249
250pub async fn add_existing_layer_to_collection(configuration: &configuration::Configuration, collection: &str, layer: &str) -> Result<(), Error<AddExistingLayerToCollectionError>> {
251    // add a prefix to parameters to efficiently prevent name collisions
252    let p_path_collection = collection;
253    let p_path_layer = layer;
254
255    let uri_str = format!("{}/layerDb/collections/{collection}/layers/{layer}", configuration.base_path, collection=crate::apis::urlencode(p_path_collection), layer=crate::apis::urlencode(p_path_layer));
256    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
257
258    if let Some(ref user_agent) = configuration.user_agent {
259        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
260    }
261    if let Some(ref token) = configuration.bearer_access_token {
262        req_builder = req_builder.bearer_auth(token.to_owned());
263    };
264
265    let req = req_builder.build()?;
266    let resp = configuration.client.execute(req).await?;
267
268    let status = resp.status();
269
270    if !status.is_client_error() && !status.is_server_error() {
271        Ok(())
272    } else {
273        let content = resp.text().await?;
274        let entity: Option<AddExistingLayerToCollectionError> = serde_json::from_str(&content).ok();
275        Err(Error::ResponseError(ResponseContent { status, content, entity }))
276    }
277}
278
279pub async fn add_layer(configuration: &configuration::Configuration, collection: &str, add_layer: models::AddLayer) -> Result<models::IdResponse, Error<AddLayerError>> {
280    // add a prefix to parameters to efficiently prevent name collisions
281    let p_path_collection = collection;
282    let p_body_add_layer = add_layer;
283
284    let uri_str = format!("{}/layerDb/collections/{collection}/layers", configuration.base_path, collection=crate::apis::urlencode(p_path_collection));
285    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
286
287    if let Some(ref user_agent) = configuration.user_agent {
288        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
289    }
290    if let Some(ref token) = configuration.bearer_access_token {
291        req_builder = req_builder.bearer_auth(token.to_owned());
292    };
293    req_builder = req_builder.json(&p_body_add_layer);
294
295    let req = req_builder.build()?;
296    let resp = configuration.client.execute(req).await?;
297
298    let status = resp.status();
299    let content_type = resp
300        .headers()
301        .get("content-type")
302        .and_then(|v| v.to_str().ok())
303        .unwrap_or("application/octet-stream");
304    let content_type = super::ContentType::from(content_type);
305
306    if !status.is_client_error() && !status.is_server_error() {
307        let content = resp.text().await?;
308        match content_type {
309            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
310            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::IdResponse`"))),
311            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IdResponse`")))),
312        }
313    } else {
314        let content = resp.text().await?;
315        let entity: Option<AddLayerError> = serde_json::from_str(&content).ok();
316        Err(Error::ResponseError(ResponseContent { status, content, entity }))
317    }
318}
319
320pub async fn add_provider(configuration: &configuration::Configuration, typed_data_provider_definition: models::TypedDataProviderDefinition) -> Result<models::IdResponse, Error<AddProviderError>> {
321    // add a prefix to parameters to efficiently prevent name collisions
322    let p_body_typed_data_provider_definition = typed_data_provider_definition;
323
324    let uri_str = format!("{}/layerDb/providers", configuration.base_path);
325    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
326
327    if let Some(ref user_agent) = configuration.user_agent {
328        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
329    }
330    if let Some(ref token) = configuration.bearer_access_token {
331        req_builder = req_builder.bearer_auth(token.to_owned());
332    };
333    req_builder = req_builder.json(&p_body_typed_data_provider_definition);
334
335    let req = req_builder.build()?;
336    let resp = configuration.client.execute(req).await?;
337
338    let status = resp.status();
339    let content_type = resp
340        .headers()
341        .get("content-type")
342        .and_then(|v| v.to_str().ok())
343        .unwrap_or("application/octet-stream");
344    let content_type = super::ContentType::from(content_type);
345
346    if !status.is_client_error() && !status.is_server_error() {
347        let content = resp.text().await?;
348        match content_type {
349            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
350            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::IdResponse`"))),
351            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IdResponse`")))),
352        }
353    } else {
354        let content = resp.text().await?;
355        let entity: Option<AddProviderError> = serde_json::from_str(&content).ok();
356        Err(Error::ResponseError(ResponseContent { status, content, entity }))
357    }
358}
359
360pub async fn autocomplete_handler(configuration: &configuration::Configuration, provider: &str, collection: &str, search_type: models::SearchType, search_string: &str, limit: i32, offset: i32) -> Result<Vec<String>, Error<AutocompleteHandlerError>> {
361    // add a prefix to parameters to efficiently prevent name collisions
362    let p_path_provider = provider;
363    let p_path_collection = collection;
364    let p_query_search_type = search_type;
365    let p_query_search_string = search_string;
366    let p_query_limit = limit;
367    let p_query_offset = offset;
368
369    let uri_str = format!("{}/layers/collections/search/autocomplete/{provider}/{collection}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), collection=crate::apis::urlencode(p_path_collection));
370    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
371
372    req_builder = req_builder.query(&[("searchType", &p_query_search_type.to_string())]);
373    req_builder = req_builder.query(&[("searchString", &p_query_search_string.to_string())]);
374    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
375    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
376    if let Some(ref user_agent) = configuration.user_agent {
377        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
378    }
379    if let Some(ref token) = configuration.bearer_access_token {
380        req_builder = req_builder.bearer_auth(token.to_owned());
381    };
382
383    let req = req_builder.build()?;
384    let resp = configuration.client.execute(req).await?;
385
386    let status = resp.status();
387    let content_type = resp
388        .headers()
389        .get("content-type")
390        .and_then(|v| v.to_str().ok())
391        .unwrap_or("application/octet-stream");
392    let content_type = super::ContentType::from(content_type);
393
394    if !status.is_client_error() && !status.is_server_error() {
395        let content = resp.text().await?;
396        match content_type {
397            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
398            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;String&gt;`"))),
399            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;String&gt;`")))),
400        }
401    } else {
402        let content = resp.text().await?;
403        let entity: Option<AutocompleteHandlerError> = serde_json::from_str(&content).ok();
404        Err(Error::ResponseError(ResponseContent { status, content, entity }))
405    }
406}
407
408pub async fn delete_provider(configuration: &configuration::Configuration, provider: &str) -> Result<(), Error<DeleteProviderError>> {
409    // add a prefix to parameters to efficiently prevent name collisions
410    let p_path_provider = provider;
411
412    let uri_str = format!("{}/layerDb/providers/{provider}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider));
413    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
414
415    if let Some(ref user_agent) = configuration.user_agent {
416        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
417    }
418    if let Some(ref token) = configuration.bearer_access_token {
419        req_builder = req_builder.bearer_auth(token.to_owned());
420    };
421
422    let req = req_builder.build()?;
423    let resp = configuration.client.execute(req).await?;
424
425    let status = resp.status();
426
427    if !status.is_client_error() && !status.is_server_error() {
428        Ok(())
429    } else {
430        let content = resp.text().await?;
431        let entity: Option<DeleteProviderError> = serde_json::from_str(&content).ok();
432        Err(Error::ResponseError(ResponseContent { status, content, entity }))
433    }
434}
435
436pub async fn get_provider_definition(configuration: &configuration::Configuration, provider: &str) -> Result<models::TypedDataProviderDefinition, Error<GetProviderDefinitionError>> {
437    // add a prefix to parameters to efficiently prevent name collisions
438    let p_path_provider = provider;
439
440    let uri_str = format!("{}/layerDb/providers/{provider}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider));
441    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
442
443    if let Some(ref user_agent) = configuration.user_agent {
444        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
445    }
446    if let Some(ref token) = configuration.bearer_access_token {
447        req_builder = req_builder.bearer_auth(token.to_owned());
448    };
449
450    let req = req_builder.build()?;
451    let resp = configuration.client.execute(req).await?;
452
453    let status = resp.status();
454    let content_type = resp
455        .headers()
456        .get("content-type")
457        .and_then(|v| v.to_str().ok())
458        .unwrap_or("application/octet-stream");
459    let content_type = super::ContentType::from(content_type);
460
461    if !status.is_client_error() && !status.is_server_error() {
462        let content = resp.text().await?;
463        match content_type {
464            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
465            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TypedDataProviderDefinition`"))),
466            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TypedDataProviderDefinition`")))),
467        }
468    } else {
469        let content = resp.text().await?;
470        let entity: Option<GetProviderDefinitionError> = serde_json::from_str(&content).ok();
471        Err(Error::ResponseError(ResponseContent { status, content, entity }))
472    }
473}
474
475pub async fn layer_handler(configuration: &configuration::Configuration, provider: &str, layer: &str) -> Result<models::Layer, Error<LayerHandlerError>> {
476    // add a prefix to parameters to efficiently prevent name collisions
477    let p_path_provider = provider;
478    let p_path_layer = layer;
479
480    let uri_str = format!("{}/layers/{provider}/{layer}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), layer=crate::apis::urlencode(p_path_layer));
481    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
482
483    if let Some(ref user_agent) = configuration.user_agent {
484        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
485    }
486    if let Some(ref token) = configuration.bearer_access_token {
487        req_builder = req_builder.bearer_auth(token.to_owned());
488    };
489
490    let req = req_builder.build()?;
491    let resp = configuration.client.execute(req).await?;
492
493    let status = resp.status();
494    let content_type = resp
495        .headers()
496        .get("content-type")
497        .and_then(|v| v.to_str().ok())
498        .unwrap_or("application/octet-stream");
499    let content_type = super::ContentType::from(content_type);
500
501    if !status.is_client_error() && !status.is_server_error() {
502        let content = resp.text().await?;
503        match content_type {
504            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
505            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Layer`"))),
506            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Layer`")))),
507        }
508    } else {
509        let content = resp.text().await?;
510        let entity: Option<LayerHandlerError> = serde_json::from_str(&content).ok();
511        Err(Error::ResponseError(ResponseContent { status, content, entity }))
512    }
513}
514
515pub async fn layer_to_dataset(configuration: &configuration::Configuration, provider: &str, layer: &str) -> Result<models::TaskResponse, Error<LayerToDatasetError>> {
516    // add a prefix to parameters to efficiently prevent name collisions
517    let p_path_provider = provider;
518    let p_path_layer = layer;
519
520    let uri_str = format!("{}/layers/{provider}/{layer}/dataset", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), layer=crate::apis::urlencode(p_path_layer));
521    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
522
523    if let Some(ref user_agent) = configuration.user_agent {
524        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
525    }
526    if let Some(ref token) = configuration.bearer_access_token {
527        req_builder = req_builder.bearer_auth(token.to_owned());
528    };
529
530    let req = req_builder.build()?;
531    let resp = configuration.client.execute(req).await?;
532
533    let status = resp.status();
534    let content_type = resp
535        .headers()
536        .get("content-type")
537        .and_then(|v| v.to_str().ok())
538        .unwrap_or("application/octet-stream");
539    let content_type = super::ContentType::from(content_type);
540
541    if !status.is_client_error() && !status.is_server_error() {
542        let content = resp.text().await?;
543        match content_type {
544            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
545            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TaskResponse`"))),
546            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TaskResponse`")))),
547        }
548    } else {
549        let content = resp.text().await?;
550        let entity: Option<LayerToDatasetError> = serde_json::from_str(&content).ok();
551        Err(Error::ResponseError(ResponseContent { status, content, entity }))
552    }
553}
554
555pub async fn layer_to_workflow_id_handler(configuration: &configuration::Configuration, provider: &str, layer: &str) -> Result<models::IdResponse, Error<LayerToWorkflowIdHandlerError>> {
556    // add a prefix to parameters to efficiently prevent name collisions
557    let p_path_provider = provider;
558    let p_path_layer = layer;
559
560    let uri_str = format!("{}/layers/{provider}/{layer}/workflowId", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), layer=crate::apis::urlencode(p_path_layer));
561    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
562
563    if let Some(ref user_agent) = configuration.user_agent {
564        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
565    }
566    if let Some(ref token) = configuration.bearer_access_token {
567        req_builder = req_builder.bearer_auth(token.to_owned());
568    };
569
570    let req = req_builder.build()?;
571    let resp = configuration.client.execute(req).await?;
572
573    let status = resp.status();
574    let content_type = resp
575        .headers()
576        .get("content-type")
577        .and_then(|v| v.to_str().ok())
578        .unwrap_or("application/octet-stream");
579    let content_type = super::ContentType::from(content_type);
580
581    if !status.is_client_error() && !status.is_server_error() {
582        let content = resp.text().await?;
583        match content_type {
584            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
585            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::IdResponse`"))),
586            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::IdResponse`")))),
587        }
588    } else {
589        let content = resp.text().await?;
590        let entity: Option<LayerToWorkflowIdHandlerError> = serde_json::from_str(&content).ok();
591        Err(Error::ResponseError(ResponseContent { status, content, entity }))
592    }
593}
594
595pub async fn list_collection_handler(configuration: &configuration::Configuration, provider: &str, collection: &str, offset: i32, limit: i32) -> Result<models::LayerCollection, Error<ListCollectionHandlerError>> {
596    // add a prefix to parameters to efficiently prevent name collisions
597    let p_path_provider = provider;
598    let p_path_collection = collection;
599    let p_query_offset = offset;
600    let p_query_limit = limit;
601
602    let uri_str = format!("{}/layers/collections/{provider}/{collection}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), collection=crate::apis::urlencode(p_path_collection));
603    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
604
605    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
606    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
607    if let Some(ref user_agent) = configuration.user_agent {
608        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
609    }
610    if let Some(ref token) = configuration.bearer_access_token {
611        req_builder = req_builder.bearer_auth(token.to_owned());
612    };
613
614    let req = req_builder.build()?;
615    let resp = configuration.client.execute(req).await?;
616
617    let status = resp.status();
618    let content_type = resp
619        .headers()
620        .get("content-type")
621        .and_then(|v| v.to_str().ok())
622        .unwrap_or("application/octet-stream");
623    let content_type = super::ContentType::from(content_type);
624
625    if !status.is_client_error() && !status.is_server_error() {
626        let content = resp.text().await?;
627        match content_type {
628            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
629            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::LayerCollection`"))),
630            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::LayerCollection`")))),
631        }
632    } else {
633        let content = resp.text().await?;
634        let entity: Option<ListCollectionHandlerError> = serde_json::from_str(&content).ok();
635        Err(Error::ResponseError(ResponseContent { status, content, entity }))
636    }
637}
638
639pub async fn list_providers(configuration: &configuration::Configuration, offset: i32, limit: i32) -> Result<Vec<models::LayerProviderListing>, Error<ListProvidersError>> {
640    // add a prefix to parameters to efficiently prevent name collisions
641    let p_query_offset = offset;
642    let p_query_limit = limit;
643
644    let uri_str = format!("{}/layerDb/providers", configuration.base_path);
645    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
646
647    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
648    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
649    if let Some(ref user_agent) = configuration.user_agent {
650        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
651    }
652    if let Some(ref token) = configuration.bearer_access_token {
653        req_builder = req_builder.bearer_auth(token.to_owned());
654    };
655
656    let req = req_builder.build()?;
657    let resp = configuration.client.execute(req).await?;
658
659    let status = resp.status();
660    let content_type = resp
661        .headers()
662        .get("content-type")
663        .and_then(|v| v.to_str().ok())
664        .unwrap_or("application/octet-stream");
665    let content_type = super::ContentType::from(content_type);
666
667    if !status.is_client_error() && !status.is_server_error() {
668        let content = resp.text().await?;
669        match content_type {
670            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
671            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::LayerProviderListing&gt;`"))),
672            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::LayerProviderListing&gt;`")))),
673        }
674    } else {
675        let content = resp.text().await?;
676        let entity: Option<ListProvidersError> = serde_json::from_str(&content).ok();
677        Err(Error::ResponseError(ResponseContent { status, content, entity }))
678    }
679}
680
681pub async fn list_root_collections_handler(configuration: &configuration::Configuration, offset: i32, limit: i32) -> Result<models::LayerCollection, Error<ListRootCollectionsHandlerError>> {
682    // add a prefix to parameters to efficiently prevent name collisions
683    let p_query_offset = offset;
684    let p_query_limit = limit;
685
686    let uri_str = format!("{}/layers/collections", configuration.base_path);
687    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
688
689    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
690    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
691    if let Some(ref user_agent) = configuration.user_agent {
692        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
693    }
694    if let Some(ref token) = configuration.bearer_access_token {
695        req_builder = req_builder.bearer_auth(token.to_owned());
696    };
697
698    let req = req_builder.build()?;
699    let resp = configuration.client.execute(req).await?;
700
701    let status = resp.status();
702    let content_type = resp
703        .headers()
704        .get("content-type")
705        .and_then(|v| v.to_str().ok())
706        .unwrap_or("application/octet-stream");
707    let content_type = super::ContentType::from(content_type);
708
709    if !status.is_client_error() && !status.is_server_error() {
710        let content = resp.text().await?;
711        match content_type {
712            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
713            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::LayerCollection`"))),
714            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::LayerCollection`")))),
715        }
716    } else {
717        let content = resp.text().await?;
718        let entity: Option<ListRootCollectionsHandlerError> = serde_json::from_str(&content).ok();
719        Err(Error::ResponseError(ResponseContent { status, content, entity }))
720    }
721}
722
723pub async fn provider_capabilities_handler(configuration: &configuration::Configuration, provider: &str) -> Result<models::ProviderCapabilities, Error<ProviderCapabilitiesHandlerError>> {
724    // add a prefix to parameters to efficiently prevent name collisions
725    let p_path_provider = provider;
726
727    let uri_str = format!("{}/layers/{provider}/capabilities", configuration.base_path, provider=crate::apis::urlencode(p_path_provider));
728    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
729
730    if let Some(ref user_agent) = configuration.user_agent {
731        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
732    }
733    if let Some(ref token) = configuration.bearer_access_token {
734        req_builder = req_builder.bearer_auth(token.to_owned());
735    };
736
737    let req = req_builder.build()?;
738    let resp = configuration.client.execute(req).await?;
739
740    let status = resp.status();
741    let content_type = resp
742        .headers()
743        .get("content-type")
744        .and_then(|v| v.to_str().ok())
745        .unwrap_or("application/octet-stream");
746    let content_type = super::ContentType::from(content_type);
747
748    if !status.is_client_error() && !status.is_server_error() {
749        let content = resp.text().await?;
750        match content_type {
751            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
752            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderCapabilities`"))),
753            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProviderCapabilities`")))),
754        }
755    } else {
756        let content = resp.text().await?;
757        let entity: Option<ProviderCapabilitiesHandlerError> = serde_json::from_str(&content).ok();
758        Err(Error::ResponseError(ResponseContent { status, content, entity }))
759    }
760}
761
762pub async fn remove_collection(configuration: &configuration::Configuration, collection: &str) -> Result<(), Error<RemoveCollectionError>> {
763    // add a prefix to parameters to efficiently prevent name collisions
764    let p_path_collection = collection;
765
766    let uri_str = format!("{}/layerDb/collections/{collection}", configuration.base_path, collection=crate::apis::urlencode(p_path_collection));
767    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
768
769    if let Some(ref user_agent) = configuration.user_agent {
770        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
771    }
772    if let Some(ref token) = configuration.bearer_access_token {
773        req_builder = req_builder.bearer_auth(token.to_owned());
774    };
775
776    let req = req_builder.build()?;
777    let resp = configuration.client.execute(req).await?;
778
779    let status = resp.status();
780
781    if !status.is_client_error() && !status.is_server_error() {
782        Ok(())
783    } else {
784        let content = resp.text().await?;
785        let entity: Option<RemoveCollectionError> = serde_json::from_str(&content).ok();
786        Err(Error::ResponseError(ResponseContent { status, content, entity }))
787    }
788}
789
790pub async fn remove_collection_from_collection(configuration: &configuration::Configuration, parent: &str, collection: &str) -> Result<(), Error<RemoveCollectionFromCollectionError>> {
791    // add a prefix to parameters to efficiently prevent name collisions
792    let p_path_parent = parent;
793    let p_path_collection = collection;
794
795    let uri_str = format!("{}/layerDb/collections/{parent}/collections/{collection}", configuration.base_path, parent=crate::apis::urlencode(p_path_parent), collection=crate::apis::urlencode(p_path_collection));
796    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
797
798    if let Some(ref user_agent) = configuration.user_agent {
799        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
800    }
801    if let Some(ref token) = configuration.bearer_access_token {
802        req_builder = req_builder.bearer_auth(token.to_owned());
803    };
804
805    let req = req_builder.build()?;
806    let resp = configuration.client.execute(req).await?;
807
808    let status = resp.status();
809
810    if !status.is_client_error() && !status.is_server_error() {
811        Ok(())
812    } else {
813        let content = resp.text().await?;
814        let entity: Option<RemoveCollectionFromCollectionError> = serde_json::from_str(&content).ok();
815        Err(Error::ResponseError(ResponseContent { status, content, entity }))
816    }
817}
818
819pub async fn remove_layer(configuration: &configuration::Configuration, layer: &str) -> Result<(), Error<RemoveLayerError>> {
820    // add a prefix to parameters to efficiently prevent name collisions
821    let p_path_layer = layer;
822
823    let uri_str = format!("{}/layerDb/layers/{layer}", configuration.base_path, layer=crate::apis::urlencode(p_path_layer));
824    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
825
826    if let Some(ref user_agent) = configuration.user_agent {
827        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
828    }
829    if let Some(ref token) = configuration.bearer_access_token {
830        req_builder = req_builder.bearer_auth(token.to_owned());
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        Ok(())
840    } else {
841        let content = resp.text().await?;
842        let entity: Option<RemoveLayerError> = serde_json::from_str(&content).ok();
843        Err(Error::ResponseError(ResponseContent { status, content, entity }))
844    }
845}
846
847pub async fn remove_layer_from_collection(configuration: &configuration::Configuration, collection: &str, layer: &str) -> Result<(), Error<RemoveLayerFromCollectionError>> {
848    // add a prefix to parameters to efficiently prevent name collisions
849    let p_path_collection = collection;
850    let p_path_layer = layer;
851
852    let uri_str = format!("{}/layerDb/collections/{collection}/layers/{layer}", configuration.base_path, collection=crate::apis::urlencode(p_path_collection), layer=crate::apis::urlencode(p_path_layer));
853    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
854
855    if let Some(ref user_agent) = configuration.user_agent {
856        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
857    }
858    if let Some(ref token) = configuration.bearer_access_token {
859        req_builder = req_builder.bearer_auth(token.to_owned());
860    };
861
862    let req = req_builder.build()?;
863    let resp = configuration.client.execute(req).await?;
864
865    let status = resp.status();
866
867    if !status.is_client_error() && !status.is_server_error() {
868        Ok(())
869    } else {
870        let content = resp.text().await?;
871        let entity: Option<RemoveLayerFromCollectionError> = serde_json::from_str(&content).ok();
872        Err(Error::ResponseError(ResponseContent { status, content, entity }))
873    }
874}
875
876pub async fn search_handler(configuration: &configuration::Configuration, provider: &str, collection: &str, search_type: models::SearchType, search_string: &str, limit: i32, offset: i32) -> Result<models::LayerCollection, Error<SearchHandlerError>> {
877    // add a prefix to parameters to efficiently prevent name collisions
878    let p_path_provider = provider;
879    let p_path_collection = collection;
880    let p_query_search_type = search_type;
881    let p_query_search_string = search_string;
882    let p_query_limit = limit;
883    let p_query_offset = offset;
884
885    let uri_str = format!("{}/layers/collections/search/{provider}/{collection}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider), collection=crate::apis::urlencode(p_path_collection));
886    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
887
888    req_builder = req_builder.query(&[("searchType", &p_query_search_type.to_string())]);
889    req_builder = req_builder.query(&[("searchString", &p_query_search_string.to_string())]);
890    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
891    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
892    if let Some(ref user_agent) = configuration.user_agent {
893        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
894    }
895    if let Some(ref token) = configuration.bearer_access_token {
896        req_builder = req_builder.bearer_auth(token.to_owned());
897    };
898
899    let req = req_builder.build()?;
900    let resp = configuration.client.execute(req).await?;
901
902    let status = resp.status();
903    let content_type = resp
904        .headers()
905        .get("content-type")
906        .and_then(|v| v.to_str().ok())
907        .unwrap_or("application/octet-stream");
908    let content_type = super::ContentType::from(content_type);
909
910    if !status.is_client_error() && !status.is_server_error() {
911        let content = resp.text().await?;
912        match content_type {
913            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
914            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::LayerCollection`"))),
915            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::LayerCollection`")))),
916        }
917    } else {
918        let content = resp.text().await?;
919        let entity: Option<SearchHandlerError> = serde_json::from_str(&content).ok();
920        Err(Error::ResponseError(ResponseContent { status, content, entity }))
921    }
922}
923
924pub async fn update_collection(configuration: &configuration::Configuration, collection: &str, update_layer_collection: models::UpdateLayerCollection) -> Result<(), Error<UpdateCollectionError>> {
925    // add a prefix to parameters to efficiently prevent name collisions
926    let p_path_collection = collection;
927    let p_body_update_layer_collection = update_layer_collection;
928
929    let uri_str = format!("{}/layerDb/collections/{collection}", configuration.base_path, collection=crate::apis::urlencode(p_path_collection));
930    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
931
932    if let Some(ref user_agent) = configuration.user_agent {
933        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
934    }
935    if let Some(ref token) = configuration.bearer_access_token {
936        req_builder = req_builder.bearer_auth(token.to_owned());
937    };
938    req_builder = req_builder.json(&p_body_update_layer_collection);
939
940    let req = req_builder.build()?;
941    let resp = configuration.client.execute(req).await?;
942
943    let status = resp.status();
944
945    if !status.is_client_error() && !status.is_server_error() {
946        Ok(())
947    } else {
948        let content = resp.text().await?;
949        let entity: Option<UpdateCollectionError> = serde_json::from_str(&content).ok();
950        Err(Error::ResponseError(ResponseContent { status, content, entity }))
951    }
952}
953
954pub async fn update_layer(configuration: &configuration::Configuration, layer: &str, update_layer: models::UpdateLayer) -> Result<(), Error<UpdateLayerError>> {
955    // add a prefix to parameters to efficiently prevent name collisions
956    let p_path_layer = layer;
957    let p_body_update_layer = update_layer;
958
959    let uri_str = format!("{}/layerDb/layers/{layer}", configuration.base_path, layer=crate::apis::urlencode(p_path_layer));
960    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
961
962    if let Some(ref user_agent) = configuration.user_agent {
963        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
964    }
965    if let Some(ref token) = configuration.bearer_access_token {
966        req_builder = req_builder.bearer_auth(token.to_owned());
967    };
968    req_builder = req_builder.json(&p_body_update_layer);
969
970    let req = req_builder.build()?;
971    let resp = configuration.client.execute(req).await?;
972
973    let status = resp.status();
974
975    if !status.is_client_error() && !status.is_server_error() {
976        Ok(())
977    } else {
978        let content = resp.text().await?;
979        let entity: Option<UpdateLayerError> = serde_json::from_str(&content).ok();
980        Err(Error::ResponseError(ResponseContent { status, content, entity }))
981    }
982}
983
984pub async fn update_provider_definition(configuration: &configuration::Configuration, provider: &str, typed_data_provider_definition: models::TypedDataProviderDefinition) -> Result<(), Error<UpdateProviderDefinitionError>> {
985    // add a prefix to parameters to efficiently prevent name collisions
986    let p_path_provider = provider;
987    let p_body_typed_data_provider_definition = typed_data_provider_definition;
988
989    let uri_str = format!("{}/layerDb/providers/{provider}", configuration.base_path, provider=crate::apis::urlencode(p_path_provider));
990    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
991
992    if let Some(ref user_agent) = configuration.user_agent {
993        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
994    }
995    if let Some(ref token) = configuration.bearer_access_token {
996        req_builder = req_builder.bearer_auth(token.to_owned());
997    };
998    req_builder = req_builder.json(&p_body_typed_data_provider_definition);
999
1000    let req = req_builder.build()?;
1001    let resp = configuration.client.execute(req).await?;
1002
1003    let status = resp.status();
1004
1005    if !status.is_client_error() && !status.is_server_error() {
1006        Ok(())
1007    } else {
1008        let content = resp.text().await?;
1009        let entity: Option<UpdateProviderDefinitionError> = serde_json::from_str(&content).ok();
1010        Err(Error::ResponseError(ResponseContent { status, content, entity }))
1011    }
1012}
1013
geoengine_api_client/apis/layers_api.rs

geoengine_api_client/apis/
layers_api.rs
