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

geoengine_api_client/apis/
layers_api.rs
