1use serde::{Deserialize, Serialize, Serializer};
2use serde_json::Map;
3
4use super::author::OutputAuthor;
5use super::copyright::OutputCopyright;
6use super::email::OutputEmail;
7use super::holder::OutputHolder;
8use super::license_detection::OutputLicenseDetection;
9use super::license_match::OutputMatch;
10use super::license_policy_entry::OutputLicensePolicyEntry;
11use super::package_data::OutputPackageData;
12use super::serde_helpers::insert_json;
13use super::tallies::OutputTallies;
14use super::url::OutputURL;
15
16#[derive(Debug, Clone, Deserialize)]
17pub struct OutputFileInfo {
18 pub name: String,
19 pub base_name: String,
20 pub extension: String,
21 pub path: String,
22 #[serde(rename = "type")]
23 pub file_type: crate::models::FileType,
24 pub mime_type: Option<String>,
25 pub file_type_label: Option<String>,
26 pub size: u64,
27 pub date: Option<String>,
28 pub sha1: Option<String>,
29 pub md5: Option<String>,
30 pub sha256: Option<String>,
31 pub sha1_git: Option<String>,
32 pub programming_language: Option<String>,
33 #[serde(default)]
34 pub package_data: Vec<OutputPackageData>,
35 #[serde(rename = "detected_license_expression_spdx")]
36 pub license_expression: Option<String>,
37 #[serde(default)]
38 pub license_detections: Vec<OutputLicenseDetection>,
39 #[serde(default, skip_serializing_if = "Vec::is_empty")]
40 pub license_clues: Vec<OutputMatch>,
41 pub percentage_of_license_text: Option<f64>,
42 #[serde(default)]
43 pub copyrights: Vec<OutputCopyright>,
44 #[serde(default)]
45 pub holders: Vec<OutputHolder>,
46 #[serde(default)]
47 pub authors: Vec<OutputAuthor>,
48 #[serde(default, skip_serializing_if = "Vec::is_empty")]
49 pub emails: Vec<OutputEmail>,
50 #[serde(default)]
51 pub urls: Vec<OutputURL>,
52 #[serde(default)]
53 pub for_packages: Vec<String>,
54 #[serde(default)]
55 pub scan_errors: Vec<String>,
56 pub license_policy: Option<Vec<OutputLicensePolicyEntry>>,
57 pub is_generated: Option<bool>,
58 pub is_binary: Option<bool>,
59 pub is_text: Option<bool>,
60 pub is_archive: Option<bool>,
61 pub is_media: Option<bool>,
62 pub is_source: Option<bool>,
63 pub is_script: Option<bool>,
64 pub files_count: Option<usize>,
65 pub dirs_count: Option<usize>,
66 pub size_count: Option<u64>,
67 pub source_count: Option<usize>,
68 #[serde(default, skip_serializing_if = "is_false")]
69 pub is_legal: bool,
70 #[serde(default, skip_serializing_if = "is_false")]
71 pub is_manifest: bool,
72 #[serde(default, skip_serializing_if = "is_false")]
73 pub is_readme: bool,
74 #[serde(default, skip_serializing_if = "is_false")]
75 pub is_top_level: bool,
76 #[serde(default, skip_serializing_if = "is_false")]
77 pub is_key_file: bool,
78 #[serde(default, skip_serializing_if = "is_false")]
79 pub is_community: bool,
80 #[serde(default, skip_serializing_if = "Vec::is_empty")]
81 pub facets: Vec<String>,
82 pub tallies: Option<OutputTallies>,
83}
84
85impl OutputFileInfo {
86 fn should_serialize_info_surface(&self) -> bool {
87 self.date.is_some()
88 || self.sha1.is_some()
89 || self.md5.is_some()
90 || self.sha256.is_some()
91 || self.sha1_git.is_some()
92 || self.mime_type.is_some()
93 || self.file_type_label.is_some()
94 || self.programming_language.is_some()
95 || self.is_binary.is_some()
96 || self.is_text.is_some()
97 || self.is_archive.is_some()
98 || self.is_media.is_some()
99 || self.is_source.is_some()
100 || self.is_script.is_some()
101 || self.files_count.is_some()
102 || self.dirs_count.is_some()
103 || self.size_count.is_some()
104 }
105}
106
107impl Serialize for OutputFileInfo {
108 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
109 where
110 S: Serializer,
111 {
112 let mut map = Map::new();
113 insert_json(&mut map, "path", &self.path)?;
114 insert_json(&mut map, "type", &self.file_type)?;
115 insert_json(&mut map, "name", &self.name)?;
116 insert_json(&mut map, "base_name", &self.base_name)?;
117 insert_json(&mut map, "extension", &self.extension)?;
118 insert_json(&mut map, "size", self.size)?;
119
120 if self.should_serialize_info_surface() {
121 insert_json(&mut map, "date", &self.date)?;
122 insert_json(&mut map, "sha1", self.sha1.as_ref())?;
123 insert_json(&mut map, "md5", self.md5.as_ref())?;
124 insert_json(&mut map, "sha256", self.sha256.as_ref())?;
125 insert_json(&mut map, "sha1_git", self.sha1_git.as_ref())?;
126 insert_json(&mut map, "mime_type", &self.mime_type)?;
127 insert_json(&mut map, "file_type", &self.file_type_label)?;
128 insert_json(&mut map, "programming_language", &self.programming_language)?;
129 insert_json(&mut map, "is_binary", self.is_binary)?;
130 insert_json(&mut map, "is_text", self.is_text)?;
131 insert_json(&mut map, "is_archive", self.is_archive)?;
132 insert_json(&mut map, "is_media", self.is_media)?;
133 insert_json(&mut map, "is_source", self.is_source)?;
134 insert_json(&mut map, "is_script", self.is_script)?;
135 insert_json(&mut map, "files_count", self.files_count)?;
136 insert_json(&mut map, "dirs_count", self.dirs_count)?;
137 insert_json(&mut map, "size_count", self.size_count)?;
138 }
139
140 insert_json(&mut map, "package_data", &self.package_data)?;
141 insert_json(
142 &mut map,
143 "detected_license_expression_spdx",
144 &self.license_expression,
145 )?;
146 insert_json(&mut map, "license_detections", &self.license_detections)?;
147 if !self.license_clues.is_empty() {
148 insert_json(&mut map, "license_clues", &self.license_clues)?;
149 }
150 if self.percentage_of_license_text.is_some() {
151 insert_json(
152 &mut map,
153 "percentage_of_license_text",
154 self.percentage_of_license_text,
155 )?;
156 }
157 insert_json(&mut map, "copyrights", &self.copyrights)?;
158 insert_json(&mut map, "holders", &self.holders)?;
159 insert_json(&mut map, "authors", &self.authors)?;
160 if !self.emails.is_empty() {
161 insert_json(&mut map, "emails", &self.emails)?;
162 }
163 insert_json(&mut map, "urls", &self.urls)?;
164 insert_json(&mut map, "for_packages", &self.for_packages)?;
165 insert_json(&mut map, "scan_errors", &self.scan_errors)?;
166 if self.license_policy.is_some() {
167 insert_json(&mut map, "license_policy", &self.license_policy)?;
168 }
169 if self.is_generated.is_some() {
170 insert_json(&mut map, "is_generated", self.is_generated)?;
171 }
172 if self.source_count.is_some() {
173 insert_json(&mut map, "source_count", self.source_count)?;
174 }
175 if self.is_legal {
176 insert_json(&mut map, "is_legal", self.is_legal)?;
177 }
178 if self.is_manifest {
179 insert_json(&mut map, "is_manifest", self.is_manifest)?;
180 }
181 if self.is_readme {
182 insert_json(&mut map, "is_readme", self.is_readme)?;
183 }
184 if self.is_top_level {
185 insert_json(&mut map, "is_top_level", self.is_top_level)?;
186 }
187 if self.is_key_file {
188 insert_json(&mut map, "is_key_file", self.is_key_file)?;
189 }
190 if self.is_community {
191 insert_json(&mut map, "is_community", self.is_community)?;
192 }
193 if !self.facets.is_empty() {
194 insert_json(&mut map, "facets", &self.facets)?;
195 }
196 if self.tallies.is_some() {
197 insert_json(&mut map, "tallies", &self.tallies)?;
198 }
199
200 map.serialize(serializer)
201 }
202}
203
204impl From<&crate::models::FileInfo> for OutputFileInfo {
205 fn from(value: &crate::models::FileInfo) -> Self {
206 Self {
207 name: value.name.clone(),
208 base_name: value.base_name.clone(),
209 extension: value.extension.clone(),
210 path: value.path.clone(),
211 file_type: value.file_type.clone(),
212 mime_type: value.mime_type.clone(),
213 file_type_label: value.file_type_label.clone(),
214 size: value.size,
215 date: value.date.clone(),
216 sha1: value.sha1.as_ref().map(|d| d.as_hex()),
217 md5: value.md5.as_ref().map(|d| d.as_hex()),
218 sha256: value.sha256.as_ref().map(|d| d.as_hex()),
219 sha1_git: value.sha1_git.as_ref().map(|d| d.as_hex()),
220 programming_language: value.programming_language.clone(),
221 package_data: value
222 .package_data
223 .iter()
224 .map(OutputPackageData::from)
225 .collect(),
226 license_expression: value.license_expression.clone(),
227 license_detections: value
228 .license_detections
229 .iter()
230 .map(OutputLicenseDetection::from)
231 .collect(),
232 license_clues: value.license_clues.iter().map(OutputMatch::from).collect(),
233 percentage_of_license_text: value.percentage_of_license_text,
234 copyrights: value.copyrights.iter().map(OutputCopyright::from).collect(),
235 holders: value.holders.iter().map(OutputHolder::from).collect(),
236 authors: value.authors.iter().map(OutputAuthor::from).collect(),
237 emails: value.emails.iter().map(OutputEmail::from).collect(),
238 urls: value.urls.iter().map(OutputURL::from).collect(),
239 for_packages: value
240 .for_packages
241 .iter()
242 .map(|uid| uid.to_string())
243 .collect(),
244 scan_errors: value.scan_errors.clone(),
245 license_policy: value
246 .license_policy
247 .as_ref()
248 .map(|v| v.iter().map(OutputLicensePolicyEntry::from).collect()),
249 is_generated: value.is_generated,
250 is_binary: value.is_binary,
251 is_text: value.is_text,
252 is_archive: value.is_archive,
253 is_media: value.is_media,
254 is_source: value.is_source,
255 is_script: value.is_script,
256 files_count: value.files_count,
257 dirs_count: value.dirs_count,
258 size_count: value.size_count,
259 source_count: value.source_count,
260 is_legal: value.is_legal,
261 is_manifest: value.is_manifest,
262 is_readme: value.is_readme,
263 is_top_level: value.is_top_level,
264 is_key_file: value.is_key_file,
265 is_community: value.is_community,
266 facets: value.facets.clone(),
267 tallies: value.tallies.as_ref().map(OutputTallies::from),
268 }
269 }
270}
271
272impl TryFrom<&OutputFileInfo> for crate::models::FileInfo {
273 type Error = String;
274 fn try_from(value: &OutputFileInfo) -> Result<Self, Self::Error> {
275 let mut package_data = Vec::with_capacity(value.package_data.len());
276 for p in &value.package_data {
277 package_data.push(crate::models::PackageData::try_from(p)?);
278 }
279 let mut license_detections = Vec::with_capacity(value.license_detections.len());
280 for d in &value.license_detections {
281 license_detections.push(crate::models::LicenseDetection::try_from(d)?);
282 }
283 let mut license_clues = Vec::with_capacity(value.license_clues.len());
284 for m in &value.license_clues {
285 license_clues.push(crate::models::Match::try_from(m)?);
286 }
287 let mut copyrights = Vec::with_capacity(value.copyrights.len());
288 for c in &value.copyrights {
289 copyrights.push(crate::models::Copyright::try_from(c)?);
290 }
291 let mut holders = Vec::with_capacity(value.holders.len());
292 for h in &value.holders {
293 holders.push(crate::models::Holder::try_from(h)?);
294 }
295 let mut authors = Vec::with_capacity(value.authors.len());
296 for a in &value.authors {
297 authors.push(crate::models::Author::try_from(a)?);
298 }
299 let mut emails = Vec::with_capacity(value.emails.len());
300 for e in &value.emails {
301 emails.push(crate::models::OutputEmail::try_from(e)?);
302 }
303 let mut urls = Vec::with_capacity(value.urls.len());
304 for u in &value.urls {
305 urls.push(crate::models::OutputURL::try_from(u)?);
306 }
307 let license_policy = value
308 .license_policy
309 .as_ref()
310 .map(|v| {
311 v.iter()
312 .map(crate::models::LicensePolicyEntry::try_from)
313 .collect::<Result<Vec<_>, _>>()
314 })
315 .transpose()?;
316 Ok(Self {
317 name: value.name.clone(),
318 base_name: value.base_name.clone(),
319 extension: value.extension.clone(),
320 path: value.path.clone(),
321 file_type: value.file_type.clone(),
322 mime_type: value.mime_type.clone(),
323 file_type_label: value.file_type_label.clone(),
324 size: value.size,
325 date: value.date.clone(),
326 sha1: value
327 .sha1
328 .as_ref()
329 .map(|s| crate::models::Sha1Digest::from_hex(s))
330 .transpose()
331 .map_err(|e| format!("invalid sha1: {}", e))?,
332 md5: value
333 .md5
334 .as_ref()
335 .map(|s| crate::models::Md5Digest::from_hex(s))
336 .transpose()
337 .map_err(|e| format!("invalid md5: {}", e))?,
338 sha256: value
339 .sha256
340 .as_ref()
341 .map(|s| crate::models::Sha256Digest::from_hex(s))
342 .transpose()
343 .map_err(|e| format!("invalid sha256: {}", e))?,
344 sha1_git: value
345 .sha1_git
346 .as_ref()
347 .map(|s| crate::models::GitSha1::from_hex(s))
348 .transpose()
349 .map_err(|e| format!("invalid sha1_git: {}", e))?,
350 programming_language: value.programming_language.clone(),
351 package_data,
352 license_expression: value.license_expression.clone(),
353 license_detections,
354 license_clues,
355 percentage_of_license_text: value.percentage_of_license_text,
356 copyrights,
357 holders,
358 authors,
359 emails,
360 urls,
361 for_packages: value
362 .for_packages
363 .iter()
364 .map(|s| crate::models::PackageUid::from_raw(s.clone()))
365 .collect(),
366 scan_errors: value.scan_errors.clone(),
367 license_policy,
368 is_generated: value.is_generated,
369 is_binary: value.is_binary,
370 is_text: value.is_text,
371 is_archive: value.is_archive,
372 is_media: value.is_media,
373 is_source: value.is_source,
374 is_script: value.is_script,
375 files_count: value.files_count,
376 dirs_count: value.dirs_count,
377 size_count: value.size_count,
378 source_count: value.source_count,
379 is_legal: value.is_legal,
380 is_manifest: value.is_manifest,
381 is_readme: value.is_readme,
382 is_top_level: value.is_top_level,
383 is_key_file: value.is_key_file,
384 is_community: value.is_community,
385 facets: value.facets.clone(),
386 tallies: value
387 .tallies
388 .as_ref()
389 .map(crate::models::Tallies::try_from)
390 .transpose()?,
391 })
392 }
393}