geoengine_api_client/apis/
datasets_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_dataset_tiles_handler`]
18#[derive(Debug, Clone, Serialize, Deserialize)]
19#[serde(untagged)]
20pub enum AddDatasetTilesHandlerError {
21    UnknownValue(serde_json::Value),
22}
23
24/// struct for typed errors of method [`auto_create_dataset_handler`]
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[serde(untagged)]
27pub enum AutoCreateDatasetHandlerError {
28    Status400(models::ErrorResponse),
29    Status401(models::ErrorResponse),
30    Status413(models::ErrorResponse),
31    Status415(models::ErrorResponse),
32    UnknownValue(serde_json::Value),
33}
34
35/// struct for typed errors of method [`create_dataset_handler`]
36#[derive(Debug, Clone, Serialize, Deserialize)]
37#[serde(untagged)]
38pub enum CreateDatasetHandlerError {
39    UnknownValue(serde_json::Value),
40}
41
42/// struct for typed errors of method [`delete_dataset_handler`]
43#[derive(Debug, Clone, Serialize, Deserialize)]
44#[serde(untagged)]
45pub enum DeleteDatasetHandlerError {
46    Status400(models::ErrorResponse),
47    Status401(models::ErrorResponse),
48    UnknownValue(serde_json::Value),
49}
50
51/// struct for typed errors of method [`get_dataset_handler`]
52#[derive(Debug, Clone, Serialize, Deserialize)]
53#[serde(untagged)]
54pub enum GetDatasetHandlerError {
55    Status400(models::ErrorResponse),
56    Status401(models::ErrorResponse),
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`get_loading_info_handler`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum GetLoadingInfoHandlerError {
64    UnknownValue(serde_json::Value),
65}
66
67/// struct for typed errors of method [`list_datasets_handler`]
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum ListDatasetsHandlerError {
71    Status400(models::ErrorResponse),
72    Status401(models::ErrorResponse),
73    UnknownValue(serde_json::Value),
74}
75
76/// struct for typed errors of method [`list_volume_file_layers_handler`]
77#[derive(Debug, Clone, Serialize, Deserialize)]
78#[serde(untagged)]
79pub enum ListVolumeFileLayersHandlerError {
80    UnknownValue(serde_json::Value),
81}
82
83/// struct for typed errors of method [`list_volumes_handler`]
84#[derive(Debug, Clone, Serialize, Deserialize)]
85#[serde(untagged)]
86pub enum ListVolumesHandlerError {
87    Status401(models::ErrorResponse),
88    UnknownValue(serde_json::Value),
89}
90
91/// struct for typed errors of method [`suggest_meta_data_handler`]
92#[derive(Debug, Clone, Serialize, Deserialize)]
93#[serde(untagged)]
94pub enum SuggestMetaDataHandlerError {
95    Status400(models::ErrorResponse),
96    Status401(models::ErrorResponse),
97    UnknownValue(serde_json::Value),
98}
99
100/// struct for typed errors of method [`update_dataset_handler`]
101#[derive(Debug, Clone, Serialize, Deserialize)]
102#[serde(untagged)]
103pub enum UpdateDatasetHandlerError {
104    Status400(models::ErrorResponse),
105    Status401(models::ErrorResponse),
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method [`update_dataset_provenance_handler`]
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum UpdateDatasetProvenanceHandlerError {
113    Status400(models::ErrorResponse),
114    Status401(models::ErrorResponse),
115    UnknownValue(serde_json::Value),
116}
117
118/// struct for typed errors of method [`update_dataset_symbology_handler`]
119#[derive(Debug, Clone, Serialize, Deserialize)]
120#[serde(untagged)]
121pub enum UpdateDatasetSymbologyHandlerError {
122    Status400(models::ErrorResponse),
123    Status401(models::ErrorResponse),
124    UnknownValue(serde_json::Value),
125}
126
127/// struct for typed errors of method [`update_loading_info_handler`]
128#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(untagged)]
130pub enum UpdateLoadingInfoHandlerError {
131    Status400(models::ErrorResponse),
132    Status401(models::ErrorResponse),
133    UnknownValue(serde_json::Value),
134}
135
136
137pub async fn add_dataset_tiles_handler(configuration: &configuration::Configuration, dataset: &str, auto_create_dataset: models::AutoCreateDataset) -> Result<(), Error<AddDatasetTilesHandlerError>> {
138    // add a prefix to parameters to efficiently prevent name collisions
139    let p_path_dataset = dataset;
140    let p_body_auto_create_dataset = auto_create_dataset;
141
142    let uri_str = format!("{}/dataset/{dataset}/tiles", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
143    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
144
145    if let Some(ref user_agent) = configuration.user_agent {
146        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
147    }
148    if let Some(ref token) = configuration.bearer_access_token {
149        req_builder = req_builder.bearer_auth(token.to_owned());
150    };
151    req_builder = req_builder.json(&p_body_auto_create_dataset);
152
153    let req = req_builder.build()?;
154    let resp = configuration.client.execute(req).await?;
155
156    let status = resp.status();
157
158    if !status.is_client_error() && !status.is_server_error() {
159        Ok(())
160    } else {
161        let content = resp.text().await?;
162        let entity: Option<AddDatasetTilesHandlerError> = serde_json::from_str(&content).ok();
163        Err(Error::ResponseError(ResponseContent { status, content, entity }))
164    }
165}
166
167pub async fn auto_create_dataset_handler(configuration: &configuration::Configuration, auto_create_dataset: models::AutoCreateDataset) -> Result<models::DatasetNameResponse, Error<AutoCreateDatasetHandlerError>> {
168    // add a prefix to parameters to efficiently prevent name collisions
169    let p_body_auto_create_dataset = auto_create_dataset;
170
171    let uri_str = format!("{}/dataset/auto", configuration.base_path);
172    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
173
174    if let Some(ref user_agent) = configuration.user_agent {
175        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
176    }
177    if let Some(ref token) = configuration.bearer_access_token {
178        req_builder = req_builder.bearer_auth(token.to_owned());
179    };
180    req_builder = req_builder.json(&p_body_auto_create_dataset);
181
182    let req = req_builder.build()?;
183    let resp = configuration.client.execute(req).await?;
184
185    let status = resp.status();
186    let content_type = resp
187        .headers()
188        .get("content-type")
189        .and_then(|v| v.to_str().ok())
190        .unwrap_or("application/octet-stream");
191    let content_type = super::ContentType::from(content_type);
192
193    if !status.is_client_error() && !status.is_server_error() {
194        let content = resp.text().await?;
195        match content_type {
196            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
197            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DatasetNameResponse`"))),
198            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::DatasetNameResponse`")))),
199        }
200    } else {
201        let content = resp.text().await?;
202        let entity: Option<AutoCreateDatasetHandlerError> = serde_json::from_str(&content).ok();
203        Err(Error::ResponseError(ResponseContent { status, content, entity }))
204    }
205}
206
207pub async fn create_dataset_handler(configuration: &configuration::Configuration, create_dataset: models::CreateDataset) -> Result<models::DatasetNameResponse, Error<CreateDatasetHandlerError>> {
208    // add a prefix to parameters to efficiently prevent name collisions
209    let p_body_create_dataset = create_dataset;
210
211    let uri_str = format!("{}/dataset", configuration.base_path);
212    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
213
214    if let Some(ref user_agent) = configuration.user_agent {
215        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
216    }
217    if let Some(ref token) = configuration.bearer_access_token {
218        req_builder = req_builder.bearer_auth(token.to_owned());
219    };
220    req_builder = req_builder.json(&p_body_create_dataset);
221
222    let req = req_builder.build()?;
223    let resp = configuration.client.execute(req).await?;
224
225    let status = resp.status();
226    let content_type = resp
227        .headers()
228        .get("content-type")
229        .and_then(|v| v.to_str().ok())
230        .unwrap_or("application/octet-stream");
231    let content_type = super::ContentType::from(content_type);
232
233    if !status.is_client_error() && !status.is_server_error() {
234        let content = resp.text().await?;
235        match content_type {
236            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
237            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DatasetNameResponse`"))),
238            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::DatasetNameResponse`")))),
239        }
240    } else {
241        let content = resp.text().await?;
242        let entity: Option<CreateDatasetHandlerError> = serde_json::from_str(&content).ok();
243        Err(Error::ResponseError(ResponseContent { status, content, entity }))
244    }
245}
246
247pub async fn delete_dataset_handler(configuration: &configuration::Configuration, dataset: &str) -> Result<(), Error<DeleteDatasetHandlerError>> {
248    // add a prefix to parameters to efficiently prevent name collisions
249    let p_path_dataset = dataset;
250
251    let uri_str = format!("{}/dataset/{dataset}", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
252    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
253
254    if let Some(ref user_agent) = configuration.user_agent {
255        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
256    }
257    if let Some(ref token) = configuration.bearer_access_token {
258        req_builder = req_builder.bearer_auth(token.to_owned());
259    };
260
261    let req = req_builder.build()?;
262    let resp = configuration.client.execute(req).await?;
263
264    let status = resp.status();
265
266    if !status.is_client_error() && !status.is_server_error() {
267        Ok(())
268    } else {
269        let content = resp.text().await?;
270        let entity: Option<DeleteDatasetHandlerError> = serde_json::from_str(&content).ok();
271        Err(Error::ResponseError(ResponseContent { status, content, entity }))
272    }
273}
274
275pub async fn get_dataset_handler(configuration: &configuration::Configuration, dataset: &str) -> Result<models::Dataset, Error<GetDatasetHandlerError>> {
276    // add a prefix to parameters to efficiently prevent name collisions
277    let p_path_dataset = dataset;
278
279    let uri_str = format!("{}/dataset/{dataset}", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
280    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
281
282    if let Some(ref user_agent) = configuration.user_agent {
283        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
284    }
285    if let Some(ref token) = configuration.bearer_access_token {
286        req_builder = req_builder.bearer_auth(token.to_owned());
287    };
288
289    let req = req_builder.build()?;
290    let resp = configuration.client.execute(req).await?;
291
292    let status = resp.status();
293    let content_type = resp
294        .headers()
295        .get("content-type")
296        .and_then(|v| v.to_str().ok())
297        .unwrap_or("application/octet-stream");
298    let content_type = super::ContentType::from(content_type);
299
300    if !status.is_client_error() && !status.is_server_error() {
301        let content = resp.text().await?;
302        match content_type {
303            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
304            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Dataset`"))),
305            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::Dataset`")))),
306        }
307    } else {
308        let content = resp.text().await?;
309        let entity: Option<GetDatasetHandlerError> = serde_json::from_str(&content).ok();
310        Err(Error::ResponseError(ResponseContent { status, content, entity }))
311    }
312}
313
314pub async fn get_loading_info_handler(configuration: &configuration::Configuration, dataset: &str) -> Result<models::MetaDataDefinition, Error<GetLoadingInfoHandlerError>> {
315    // add a prefix to parameters to efficiently prevent name collisions
316    let p_path_dataset = dataset;
317
318    let uri_str = format!("{}/dataset/{dataset}/loadingInfo", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
319    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
320
321    if let Some(ref user_agent) = configuration.user_agent {
322        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
323    }
324    if let Some(ref token) = configuration.bearer_access_token {
325        req_builder = req_builder.bearer_auth(token.to_owned());
326    };
327
328    let req = req_builder.build()?;
329    let resp = configuration.client.execute(req).await?;
330
331    let status = resp.status();
332    let content_type = resp
333        .headers()
334        .get("content-type")
335        .and_then(|v| v.to_str().ok())
336        .unwrap_or("application/octet-stream");
337    let content_type = super::ContentType::from(content_type);
338
339    if !status.is_client_error() && !status.is_server_error() {
340        let content = resp.text().await?;
341        match content_type {
342            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
343            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MetaDataDefinition`"))),
344            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::MetaDataDefinition`")))),
345        }
346    } else {
347        let content = resp.text().await?;
348        let entity: Option<GetLoadingInfoHandlerError> = serde_json::from_str(&content).ok();
349        Err(Error::ResponseError(ResponseContent { status, content, entity }))
350    }
351}
352
353pub async fn list_datasets_handler(configuration: &configuration::Configuration, order: models::OrderBy, offset: i32, limit: i32, filter: Option<&str>, tags: Option<Vec<String>>) -> Result<Vec<models::DatasetListing>, Error<ListDatasetsHandlerError>> {
354    // add a prefix to parameters to efficiently prevent name collisions
355    let p_query_order = order;
356    let p_query_offset = offset;
357    let p_query_limit = limit;
358    let p_query_filter = filter;
359    let p_query_tags = tags;
360
361    let uri_str = format!("{}/datasets", configuration.base_path);
362    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
363
364    if let Some(ref param_value) = p_query_filter {
365        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
366    }
367    req_builder = req_builder.query(&[("order", &p_query_order.to_string())]);
368    req_builder = req_builder.query(&[("offset", &p_query_offset.to_string())]);
369    req_builder = req_builder.query(&[("limit", &p_query_limit.to_string())]);
370    if let Some(ref param_value) = p_query_tags {
371        req_builder = match "multi" {
372            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
373            _ => req_builder.query(&[("tags", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
374        };
375    }
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;models::DatasetListing&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;models::DatasetListing&gt;`")))),
400        }
401    } else {
402        let content = resp.text().await?;
403        let entity: Option<ListDatasetsHandlerError> = serde_json::from_str(&content).ok();
404        Err(Error::ResponseError(ResponseContent { status, content, entity }))
405    }
406}
407
408pub async fn list_volume_file_layers_handler(configuration: &configuration::Configuration, volume_name: &str, file_name: &str) -> Result<models::VolumeFileLayersResponse, Error<ListVolumeFileLayersHandlerError>> {
409    // add a prefix to parameters to efficiently prevent name collisions
410    let p_path_volume_name = volume_name;
411    let p_path_file_name = file_name;
412
413    let uri_str = format!("{}/dataset/volumes/{volume_name}/files/{file_name}/layers", configuration.base_path, volume_name=crate::apis::urlencode(p_path_volume_name), file_name=crate::apis::urlencode(p_path_file_name));
414    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
415
416    if let Some(ref user_agent) = configuration.user_agent {
417        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
418    }
419    if let Some(ref token) = configuration.bearer_access_token {
420        req_builder = req_builder.bearer_auth(token.to_owned());
421    };
422
423    let req = req_builder.build()?;
424    let resp = configuration.client.execute(req).await?;
425
426    let status = resp.status();
427    let content_type = resp
428        .headers()
429        .get("content-type")
430        .and_then(|v| v.to_str().ok())
431        .unwrap_or("application/octet-stream");
432    let content_type = super::ContentType::from(content_type);
433
434    if !status.is_client_error() && !status.is_server_error() {
435        let content = resp.text().await?;
436        match content_type {
437            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
438            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VolumeFileLayersResponse`"))),
439            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::VolumeFileLayersResponse`")))),
440        }
441    } else {
442        let content = resp.text().await?;
443        let entity: Option<ListVolumeFileLayersHandlerError> = serde_json::from_str(&content).ok();
444        Err(Error::ResponseError(ResponseContent { status, content, entity }))
445    }
446}
447
448pub async fn list_volumes_handler(configuration: &configuration::Configuration, ) -> Result<Vec<models::Volume>, Error<ListVolumesHandlerError>> {
449
450    let uri_str = format!("{}/dataset/volumes", configuration.base_path);
451    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
452
453    if let Some(ref user_agent) = configuration.user_agent {
454        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
455    }
456    if let Some(ref token) = configuration.bearer_access_token {
457        req_builder = req_builder.bearer_auth(token.to_owned());
458    };
459
460    let req = req_builder.build()?;
461    let resp = configuration.client.execute(req).await?;
462
463    let status = resp.status();
464    let content_type = resp
465        .headers()
466        .get("content-type")
467        .and_then(|v| v.to_str().ok())
468        .unwrap_or("application/octet-stream");
469    let content_type = super::ContentType::from(content_type);
470
471    if !status.is_client_error() && !status.is_server_error() {
472        let content = resp.text().await?;
473        match content_type {
474            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
475            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::Volume&gt;`"))),
476            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::Volume&gt;`")))),
477        }
478    } else {
479        let content = resp.text().await?;
480        let entity: Option<ListVolumesHandlerError> = serde_json::from_str(&content).ok();
481        Err(Error::ResponseError(ResponseContent { status, content, entity }))
482    }
483}
484
485pub async fn suggest_meta_data_handler(configuration: &configuration::Configuration, suggest_meta_data: models::SuggestMetaData) -> Result<models::MetaDataSuggestion, Error<SuggestMetaDataHandlerError>> {
486    // add a prefix to parameters to efficiently prevent name collisions
487    let p_body_suggest_meta_data = suggest_meta_data;
488
489    let uri_str = format!("{}/dataset/suggest", configuration.base_path);
490    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
491
492    if let Some(ref user_agent) = configuration.user_agent {
493        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
494    }
495    if let Some(ref token) = configuration.bearer_access_token {
496        req_builder = req_builder.bearer_auth(token.to_owned());
497    };
498    req_builder = req_builder.json(&p_body_suggest_meta_data);
499
500    let req = req_builder.build()?;
501    let resp = configuration.client.execute(req).await?;
502
503    let status = resp.status();
504    let content_type = resp
505        .headers()
506        .get("content-type")
507        .and_then(|v| v.to_str().ok())
508        .unwrap_or("application/octet-stream");
509    let content_type = super::ContentType::from(content_type);
510
511    if !status.is_client_error() && !status.is_server_error() {
512        let content = resp.text().await?;
513        match content_type {
514            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
515            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MetaDataSuggestion`"))),
516            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::MetaDataSuggestion`")))),
517        }
518    } else {
519        let content = resp.text().await?;
520        let entity: Option<SuggestMetaDataHandlerError> = serde_json::from_str(&content).ok();
521        Err(Error::ResponseError(ResponseContent { status, content, entity }))
522    }
523}
524
525pub async fn update_dataset_handler(configuration: &configuration::Configuration, dataset: &str, update_dataset: models::UpdateDataset) -> Result<(), Error<UpdateDatasetHandlerError>> {
526    // add a prefix to parameters to efficiently prevent name collisions
527    let p_path_dataset = dataset;
528    let p_body_update_dataset = update_dataset;
529
530    let uri_str = format!("{}/dataset/{dataset}", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
531    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
532
533    if let Some(ref user_agent) = configuration.user_agent {
534        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
535    }
536    if let Some(ref token) = configuration.bearer_access_token {
537        req_builder = req_builder.bearer_auth(token.to_owned());
538    };
539    req_builder = req_builder.json(&p_body_update_dataset);
540
541    let req = req_builder.build()?;
542    let resp = configuration.client.execute(req).await?;
543
544    let status = resp.status();
545
546    if !status.is_client_error() && !status.is_server_error() {
547        Ok(())
548    } else {
549        let content = resp.text().await?;
550        let entity: Option<UpdateDatasetHandlerError> = serde_json::from_str(&content).ok();
551        Err(Error::ResponseError(ResponseContent { status, content, entity }))
552    }
553}
554
555pub async fn update_dataset_provenance_handler(configuration: &configuration::Configuration, dataset: &str, provenances: models::Provenances) -> Result<(), Error<UpdateDatasetProvenanceHandlerError>> {
556    // add a prefix to parameters to efficiently prevent name collisions
557    let p_path_dataset = dataset;
558    let p_body_provenances = provenances;
559
560    let uri_str = format!("{}/dataset/{dataset}/provenance", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
561    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &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    req_builder = req_builder.json(&p_body_provenances);
570
571    let req = req_builder.build()?;
572    let resp = configuration.client.execute(req).await?;
573
574    let status = resp.status();
575
576    if !status.is_client_error() && !status.is_server_error() {
577        Ok(())
578    } else {
579        let content = resp.text().await?;
580        let entity: Option<UpdateDatasetProvenanceHandlerError> = serde_json::from_str(&content).ok();
581        Err(Error::ResponseError(ResponseContent { status, content, entity }))
582    }
583}
584
585pub async fn update_dataset_symbology_handler(configuration: &configuration::Configuration, dataset: &str, symbology: models::Symbology) -> Result<(), Error<UpdateDatasetSymbologyHandlerError>> {
586    // add a prefix to parameters to efficiently prevent name collisions
587    let p_path_dataset = dataset;
588    let p_body_symbology = symbology;
589
590    let uri_str = format!("{}/dataset/{dataset}/symbology", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
591    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
592
593    if let Some(ref user_agent) = configuration.user_agent {
594        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
595    }
596    if let Some(ref token) = configuration.bearer_access_token {
597        req_builder = req_builder.bearer_auth(token.to_owned());
598    };
599    req_builder = req_builder.json(&p_body_symbology);
600
601    let req = req_builder.build()?;
602    let resp = configuration.client.execute(req).await?;
603
604    let status = resp.status();
605
606    if !status.is_client_error() && !status.is_server_error() {
607        Ok(())
608    } else {
609        let content = resp.text().await?;
610        let entity: Option<UpdateDatasetSymbologyHandlerError> = serde_json::from_str(&content).ok();
611        Err(Error::ResponseError(ResponseContent { status, content, entity }))
612    }
613}
614
615pub async fn update_loading_info_handler(configuration: &configuration::Configuration, dataset: &str, meta_data_definition: models::MetaDataDefinition) -> Result<(), Error<UpdateLoadingInfoHandlerError>> {
616    // add a prefix to parameters to efficiently prevent name collisions
617    let p_path_dataset = dataset;
618    let p_body_meta_data_definition = meta_data_definition;
619
620    let uri_str = format!("{}/dataset/{dataset}/loadingInfo", configuration.base_path, dataset=crate::apis::urlencode(p_path_dataset));
621    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
622
623    if let Some(ref user_agent) = configuration.user_agent {
624        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
625    }
626    if let Some(ref token) = configuration.bearer_access_token {
627        req_builder = req_builder.bearer_auth(token.to_owned());
628    };
629    req_builder = req_builder.json(&p_body_meta_data_definition);
630
631    let req = req_builder.build()?;
632    let resp = configuration.client.execute(req).await?;
633
634    let status = resp.status();
635
636    if !status.is_client_error() && !status.is_server_error() {
637        Ok(())
638    } else {
639        let content = resp.text().await?;
640        let entity: Option<UpdateLoadingInfoHandlerError> = serde_json::from_str(&content).ok();
641        Err(Error::ResponseError(ResponseContent { status, content, entity }))
642    }
643}
644
geoengine_api_client/apis/datasets_api.rs

geoengine_api_client/apis/
datasets_api.rs
