13809415963

Committed 12 Mar 2025 10:42AM UTC coverage: 90.026% (-0.05%) from 90.076%

Build # 13809415963

Build Type

Pull #1013

github

Committed by

web-flow

Commit Message

Merge b51e2554c into c96026921

Pull Request Pull Request #1013: Update-utoipa

Run Details

787 of 935 new or added lines in 41 files covered. (84.17%)

28 existing lines in 10 files now uncovered.

125995 of 139954 relevant lines covered (90.03%)

57510.86 hits per line

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

56.98

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

use crate::api::model::operators::{
    GdalMetaDataList, GdalMetaDataRegular, GdalMetaDataStatic, GdalMetadataNetCdfCf, MockMetaData,
    OgrMetaData,
};
use crate::datasets::storage::validate_tags;
use crate::datasets::upload::{UploadId, VolumeName};
use crate::datasets::DatasetName;
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(),
                    inner: x.into(),
                })
            }
            crate::datasets::storage::MetaDataDefinition::OgrMetaData(x) => {
                Self::OgrMetaData(OgrMetaData {
                    r#type: Default::default(),
                    inner: x.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>,
}

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

geo-engine / geoengine / 13809415963

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