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

geoengine_api_client/apis/
datasets_api.rs
