13988686027

Committed 21 Mar 2025 09:30AM UTC coverage: 90.016%. First build

Build # 13988686027

Build Type

Pull #1013

github

Committed by

web-flow

Commit Message

Merge c56dbfaff into 89b08c00f

Pull Request Pull Request #1013: Update-utoipa

Run Details

1088 of 1303 new or added lines in 47 files covered. (83.5%)

126708 of 140762 relevant lines covered (90.02%)

57181.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.57

/services/src/api/model/services.rs

use std::path::PathBuf;

use crate::api::model::operators::{
    GdalMetaDataList, GdalMetaDataRegular, GdalMetaDataStatic, GdalMetadataNetCdfCf, MockMetaData,
    OgrMetaData,
};
use crate::datasets::DatasetName;
use crate::datasets::storage::validate_tags;
use crate::datasets::upload::{UploadId, VolumeName};
use crate::projects::Symbology;
use serde::{Deserialize, Serialize};
use utoipa::ToSchema;
use validator::{Validate, ValidationErrors};

use super::datatypes::DataId;

#[allow(clippy::large_enum_variant)]
#[derive(Serialize, Deserialize, Debug, Clone, ToSchema, PartialEq)]
#[serde(untagged)]
#[schema(discriminator = "type")]
pub enum MetaDataDefinition {
    MockMetaData(MockMetaData),
    OgrMetaData(OgrMetaData),
    GdalMetaDataRegular(GdalMetaDataRegular),
    GdalStatic(GdalMetaDataStatic),
    GdalMetadataNetCdfCf(GdalMetadataNetCdfCf),
    GdalMetaDataList(GdalMetaDataList),
}

impl From<crate::datasets::storage::MetaDataDefinition> for MetaDataDefinition {
    fn from(value: crate::datasets::storage::MetaDataDefinition) -> Self {
        match value {
            crate::datasets::storage::MetaDataDefinition::MockMetaData(x) => {
                Self::MockMetaData(MockMetaData {
                    r#type: Default::default(),
                    loading_info: x.loading_info.into(),
                    result_descriptor: x.result_descriptor.into(),
                })
            }
            crate::datasets::storage::MetaDataDefinition::OgrMetaData(x) => {
                Self::OgrMetaData(OgrMetaData {
                    r#type: Default::default(),
                    loading_info: x.loading_info.into(),
                    result_descriptor: x.result_descriptor.into(),
                })
            }
            crate::datasets::storage::MetaDataDefinition::GdalMetaDataRegular(x) => {
                Self::GdalMetaDataRegular(x.into())
            }
            crate::datasets::storage::MetaDataDefinition::GdalStatic(x) => {
                Self::GdalStatic(x.into())
            }
            crate::datasets::storage::MetaDataDefinition::GdalMetadataNetCdfCf(x) => {
                Self::GdalMetadataNetCdfCf(x.into())
            }
            crate::datasets::storage::MetaDataDefinition::GdalMetaDataList(x) => {
                Self::GdalMetaDataList(x.into())
            }
        }
    }
}

impl From<MetaDataDefinition> for crate::datasets::storage::MetaDataDefinition {
    fn from(value: MetaDataDefinition) -> Self {
        match value {
            MetaDataDefinition::MockMetaData(x) => Self::MockMetaData(x.into()),
            MetaDataDefinition::OgrMetaData(x) => Self::OgrMetaData(x.into()),
            MetaDataDefinition::GdalMetaDataRegular(x) => Self::GdalMetaDataRegular(x.into()),
            MetaDataDefinition::GdalStatic(x) => Self::GdalStatic(x.into()),
            MetaDataDefinition::GdalMetadataNetCdfCf(x) => Self::GdalMetadataNetCdfCf(x.into()),
            MetaDataDefinition::GdalMetaDataList(x) => Self::GdalMetaDataList(x.into()),
        }
    }
}

#[derive(Deserialize, Serialize, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct MetaDataSuggestion {
    pub main_file: String,
    pub layer_name: String,
    pub meta_data: MetaDataDefinition,
}

#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]
#[serde(rename_all = "camelCase")]
// TODO: validate user input
pub struct AddDataset {
    pub name: Option<DatasetName>,
    pub display_name: String,
    pub description: String,
    pub source_operator: String,
    pub symbology: Option<Symbology>,
    pub provenance: Option<Vec<Provenance>>,
    pub tags: Option<Vec<String>>,
}

impl From<AddDataset> for crate::datasets::storage::AddDataset {
    fn from(value: AddDataset) -> Self {
        Self {
            name: value.name,
            display_name: value.display_name,
            description: value.description,
            source_operator: value.source_operator,
            symbology: value.symbology,
            provenance: value
                .provenance
                .map(|v| v.into_iter().map(Into::into).collect()),
            tags: value.tags,
        }
    }
}

impl From<crate::datasets::storage::AddDataset> for AddDataset {
    fn from(value: crate::datasets::storage::AddDataset) -> Self {
        Self {
            name: value.name,
            display_name: value.display_name,
            description: value.description,
            source_operator: value.source_operator,
            symbology: value.symbology,
            provenance: value
                .provenance
                .map(|v| v.into_iter().map(Into::into).collect()),
            tags: value.tags,
        }
    }
}

#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct DatasetDefinition {
    pub properties: AddDataset,
    pub meta_data: MetaDataDefinition,
}

#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct CreateDataset {
    pub data_path: DataPath,
    pub definition: DatasetDefinition,
}

#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]
#[serde(rename_all = "camelCase")]
pub enum DataPath {
    Volume(VolumeName),
    Upload(UploadId),
}

#[derive(Deserialize, Serialize, Debug, Clone, ToSchema, Validate)]
pub struct UpdateDataset {
    pub name: DatasetName,
    #[validate(length(min = 1))]
    pub display_name: String,
    pub description: String,
    #[validate(custom(function = "validate_tags"))]
    pub tags: Vec<String>,
}

#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone, ToSchema, Validate)]
pub struct Provenance {
    #[validate(length(min = 1))]
    pub citation: String,
    #[validate(length(min = 1))]
    pub license: String,
    #[validate(length(min = 1))]
    pub uri: String,
}

impl From<Provenance> for crate::datasets::listing::Provenance {
    fn from(value: Provenance) -> Self {
        Self {
            citation: value.citation,
            license: value.license,
            uri: value.uri,
        }
    }
}

impl From<crate::datasets::listing::Provenance> for Provenance {
    fn from(value: crate::datasets::listing::Provenance) -> Self {
        Self {
            citation: value.citation,
            license: value.license,
            uri: value.uri,
        }
    }
}

#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]
pub struct Provenances {
    pub provenances: Vec<Provenance>,
}

impl Validate for Provenances {
    fn validate(&self) -> Result<(), ValidationErrors> {
        for provenance in &self.provenances {
            provenance.validate()?;
        }
        Ok(())
    }
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, ToSchema)]
pub struct ProvenanceOutput {
    pub data: DataId,
    pub provenance: Option<Vec<Provenance>>,
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, ToSchema)]
pub struct Volume {
    pub name: String,
    pub path: Option<String>,
}

impl From<&Volume> for crate::datasets::upload::Volume {
    fn from(value: &Volume) -> Self {
        Self {
            name: VolumeName(value.name.clone()),
            path: value.path.as_ref().map_or_else(PathBuf::new, PathBuf::from),
        }
    }
}

1	use std::path::PathBuf;
2
3	use crate::api::model::operators::{
4	GdalMetaDataList, GdalMetaDataRegular, GdalMetaDataStatic, GdalMetadataNetCdfCf, MockMetaData,
5	OgrMetaData,
6	};
7	use crate::datasets::DatasetName;
8	use crate::datasets::storage::validate_tags;
9	use crate::datasets::upload::{UploadId, VolumeName};
10	use crate::projects::Symbology;
11	use serde::{Deserialize, Serialize};
12	use utoipa::ToSchema;
13	use validator::{Validate, ValidationErrors};
14
15	use super::datatypes::DataId;
16
17	#[allow(clippy::large_enum_variant)]
18	#[derive(Serialize, Deserialize, Debug, Clone, ToSchema, PartialEq)]	155✔
19	#[serde(untagged)]
20	#[schema(discriminator = "type")]
21	pub enum MetaDataDefinition {
22	MockMetaData(MockMetaData),
23	OgrMetaData(OgrMetaData),
24	GdalMetaDataRegular(GdalMetaDataRegular),
25	GdalStatic(GdalMetaDataStatic),
26	GdalMetadataNetCdfCf(GdalMetadataNetCdfCf),
27	GdalMetaDataList(GdalMetaDataList),
28	}
29
30	impl From<crate::datasets::storage::MetaDataDefinition> for MetaDataDefinition {
31	fn from(value: crate::datasets::storage::MetaDataDefinition) -> Self {	4✔
32	match value {	4✔
33	crate::datasets::storage::MetaDataDefinition::MockMetaData(x) => {	×
NEW 34	Self::MockMetaData(MockMetaData {	×
NEW 35	r#type: Default::default(),	×
NEW 36	loading_info: x.loading_info.into(),	×
NEW 37	result_descriptor: x.result_descriptor.into(),	×
NEW 38	})	×
39	}
40	crate::datasets::storage::MetaDataDefinition::OgrMetaData(x) => {	4✔
41	Self::OgrMetaData(OgrMetaData {	4✔
42	r#type: Default::default(),	4✔
43	loading_info: x.loading_info.into(),	4✔
44	result_descriptor: x.result_descriptor.into(),	4✔
45	})	4✔
46	}
47	crate::datasets::storage::MetaDataDefinition::GdalMetaDataRegular(x) => {	×
48	Self::GdalMetaDataRegular(x.into())	×
49	}
50	crate::datasets::storage::MetaDataDefinition::GdalStatic(x) => {	×
51	Self::GdalStatic(x.into())	×
52	}
53	crate::datasets::storage::MetaDataDefinition::GdalMetadataNetCdfCf(x) => {	×
54	Self::GdalMetadataNetCdfCf(x.into())	×
55	}
56	crate::datasets::storage::MetaDataDefinition::GdalMetaDataList(x) => {	×
57	Self::GdalMetaDataList(x.into())	×
58	}
59	}
60	}	4✔
61	}
62
63	impl From<MetaDataDefinition> for crate::datasets::storage::MetaDataDefinition {
64	fn from(value: MetaDataDefinition) -> Self {	7✔
65	match value {	7✔
66	MetaDataDefinition::MockMetaData(x) => Self::MockMetaData(x.into()),	×
67	MetaDataDefinition::OgrMetaData(x) => Self::OgrMetaData(x.into()),	3✔
68	MetaDataDefinition::GdalMetaDataRegular(x) => Self::GdalMetaDataRegular(x.into()),	4✔
69	MetaDataDefinition::GdalStatic(x) => Self::GdalStatic(x.into()),	×
70	MetaDataDefinition::GdalMetadataNetCdfCf(x) => Self::GdalMetadataNetCdfCf(x.into()),	×
71	MetaDataDefinition::GdalMetaDataList(x) => Self::GdalMetaDataList(x.into()),	×
72	}
73	}	7✔
74	}
75
76	#[derive(Deserialize, Serialize, ToSchema)]	35✔
77	#[serde(rename_all = "camelCase")]
78	pub struct MetaDataSuggestion {
79	pub main_file: String,
80	pub layer_name: String,
81	pub meta_data: MetaDataDefinition,
82	}
83
84	#[derive(Debug, Serialize, Deserialize, Clone, ToSchema)]	55✔
85	#[serde(rename_all = "camelCase")]
86	// TODO: validate user input
87	pub struct AddDataset {
88	pub name: Option<DatasetName>,
89	pub display_name: String,
90	pub description: String,
91	pub source_operator: String,
92	pub symbology: Option<Symbology>,
93	pub provenance: Option<Vec<Provenance>>,
94	pub tags: Option<Vec<String>>,
95	}
96
97	impl From<AddDataset> for crate::datasets::storage::AddDataset {
98	fn from(value: AddDataset) -> Self {	11✔
99	Self {	11✔
100	name: value.name,	11✔
101	display_name: value.display_name,	11✔
102	description: value.description,	11✔
103	source_operator: value.source_operator,	11✔
104	symbology: value.symbology,	11✔
105	provenance: value	11✔
106	.provenance	11✔
107	.map(\|v\| v.into_iter().map(Into::into).collect()),	11✔
108	tags: value.tags,	11✔
109	}	11✔
110	}	11✔
111	}
112
113	impl From<crate::datasets::storage::AddDataset> for AddDataset {
114	fn from(value: crate::datasets::storage::AddDataset) -> Self {	×
115	Self {	×
116	name: value.name,	×
117	display_name: value.display_name,	×
118	description: value.description,	×
119	source_operator: value.source_operator,	×
120	symbology: value.symbology,	×
121	provenance: value	×
122	.provenance	×
123	.map(\|v\| v.into_iter().map(Into::into).collect()),	×
124	tags: value.tags,	×
125	}	×
126	}	×
127	}
128
129	#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]	55✔
130	#[serde(rename_all = "camelCase")]
131	pub struct DatasetDefinition {
132	pub properties: AddDataset,
133	pub meta_data: MetaDataDefinition,
134	}
135
136	#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]	35✔
137	#[serde(rename_all = "camelCase")]
138	pub struct CreateDataset {
139	pub data_path: DataPath,
140	pub definition: DatasetDefinition,
141	}
142
143	#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]	95✔
144	#[serde(rename_all = "camelCase")]
145	pub enum DataPath {
146	Volume(VolumeName),
147	Upload(UploadId),
148	}
149
150	#[derive(Deserialize, Serialize, Debug, Clone, ToSchema, Validate)]	35✔
151	pub struct UpdateDataset {
152	pub name: DatasetName,
153	#[validate(length(min = 1))]
154	pub display_name: String,
155	pub description: String,
156	#[validate(custom(function = "validate_tags"))]
157	pub tags: Vec<String>,
158	}
159
160	#[derive(Deserialize, Serialize, PartialEq, Eq, Debug, Clone, ToSchema, Validate)]	155✔
161	pub struct Provenance {
162	#[validate(length(min = 1))]
163	pub citation: String,
164	#[validate(length(min = 1))]
165	pub license: String,
166	#[validate(length(min = 1))]
167	pub uri: String,
168	}
169
170	impl From<Provenance> for crate::datasets::listing::Provenance {
171	fn from(value: Provenance) -> Self {	2✔
172	Self {	2✔
173	citation: value.citation,	2✔
174	license: value.license,	2✔
175	uri: value.uri,	2✔
176	}	2✔
177	}	2✔
178	}
179
180	impl From<crate::datasets::listing::Provenance> for Provenance {
181	fn from(value: crate::datasets::listing::Provenance) -> Self {	×
182	Self {	×
183	citation: value.citation,	×
184	license: value.license,	×
185	uri: value.uri,	×
186	}	×
187	}	×
188	}
189
190	#[derive(Deserialize, Serialize, Debug, Clone, ToSchema)]	35✔
191	pub struct Provenances {
192	pub provenances: Vec<Provenance>,
193	}
194
195	impl Validate for Provenances {
196	fn validate(&self) -> Result<(), ValidationErrors> {	1✔
197	for provenance in &self.provenances {	2✔
198	provenance.validate()?;	1✔
199	}
200	Ok(())	1✔
201	}	1✔
202	}
203
204	#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, ToSchema)]	10✔
205	pub struct ProvenanceOutput {
206	pub data: DataId,
207	pub provenance: Option<Vec<Provenance>>,
208	}
209
210	#[derive(Debug, Serialize, Deserialize, PartialEq, Eq, ToSchema)]	25✔
211	pub struct Volume {
212	pub name: String,
213	pub path: Option<String>,
214	}
215
216	impl From<&Volume> for crate::datasets::upload::Volume {
217	fn from(value: &Volume) -> Self {	4✔
218	Self {	4✔
219	name: VolumeName(value.name.clone()),	4✔
220	path: value.path.as_ref().map_or_else(PathBuf::new, PathBuf::from),	4✔
221	}	4✔
222	}	4✔
223	}

geo-engine / geoengine / 13988686027

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous