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 pub(crate) 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 pub(crate) fn should_serialize_license_surface(&self) -> bool {
107 self.license_expression.is_some()
108 || !self.license_detections.is_empty()
109 || !self.license_clues.is_empty()
110 || self.percentage_of_license_text.is_some()
111 }
112
113 pub(crate) fn detected_license_expression_spdx(&self) -> Option<String> {
114 crate::utils::spdx::combine_license_expressions(
115 self.license_detections
116 .iter()
117 .filter(|detection| !detection.license_expression_spdx.is_empty())
118 .map(|detection| detection.license_expression_spdx.clone()),
119 )
120 .or_else(|| {
121 crate::utils::spdx::combine_license_expressions(
122 self.package_data
123 .iter()
124 .flat_map(|package_data| package_data.license_detections.iter())
125 .filter(|detection| !detection.license_expression_spdx.is_empty())
126 .map(|detection| detection.license_expression_spdx.clone()),
127 )
128 })
129 .or_else(|| {
130 self.license_expression
131 .clone()
132 .filter(|expression| !expression.is_empty())
133 })
134 }
135}
136
137impl Serialize for OutputFileInfo {
138 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
139 where
140 S: Serializer,
141 {
142 let mut map = Map::new();
143 insert_json(&mut map, "path", &self.path)?;
144 insert_json(&mut map, "type", &self.file_type)?;
145 insert_json(&mut map, "name", &self.name)?;
146 insert_json(&mut map, "base_name", &self.base_name)?;
147 insert_json(&mut map, "extension", &self.extension)?;
148 insert_json(&mut map, "size", self.size)?;
149
150 if self.should_serialize_info_surface() {
151 insert_json(&mut map, "date", &self.date)?;
152 insert_json(&mut map, "sha1", self.sha1.as_ref())?;
153 insert_json(&mut map, "md5", self.md5.as_ref())?;
154 insert_json(&mut map, "sha256", self.sha256.as_ref())?;
155 insert_json(&mut map, "sha1_git", self.sha1_git.as_ref())?;
156 insert_json(&mut map, "mime_type", &self.mime_type)?;
157 insert_json(&mut map, "file_type", &self.file_type_label)?;
158 insert_json(&mut map, "programming_language", &self.programming_language)?;
159 insert_json(&mut map, "is_binary", self.is_binary)?;
160 insert_json(&mut map, "is_text", self.is_text)?;
161 insert_json(&mut map, "is_archive", self.is_archive)?;
162 insert_json(&mut map, "is_media", self.is_media)?;
163 insert_json(&mut map, "is_source", self.is_source)?;
164 insert_json(&mut map, "is_script", self.is_script)?;
165 insert_json(&mut map, "files_count", self.files_count)?;
166 insert_json(&mut map, "dirs_count", self.dirs_count)?;
167 insert_json(&mut map, "size_count", self.size_count)?;
168 }
169
170 insert_json(&mut map, "package_data", &self.package_data)?;
171 insert_json(
172 &mut map,
173 "detected_license_expression_spdx",
174 self.detected_license_expression_spdx(),
175 )?;
176 insert_json(&mut map, "license_detections", &self.license_detections)?;
177 if self.should_serialize_license_surface() {
178 insert_json(&mut map, "license_clues", &self.license_clues)?;
179 }
180 if self.percentage_of_license_text.is_some() {
181 insert_json(
182 &mut map,
183 "percentage_of_license_text",
184 self.percentage_of_license_text,
185 )?;
186 }
187 insert_json(&mut map, "copyrights", &self.copyrights)?;
188 insert_json(&mut map, "holders", &self.holders)?;
189 insert_json(&mut map, "authors", &self.authors)?;
190 if !self.emails.is_empty() {
191 insert_json(&mut map, "emails", &self.emails)?;
192 }
193 insert_json(&mut map, "urls", &self.urls)?;
194 insert_json(&mut map, "for_packages", &self.for_packages)?;
195 insert_json(&mut map, "scan_errors", &self.scan_errors)?;
196 if self.license_policy.is_some() {
197 insert_json(&mut map, "license_policy", &self.license_policy)?;
198 }
199 if self.is_generated.is_some() {
200 insert_json(&mut map, "is_generated", self.is_generated)?;
201 }
202 if self.source_count.is_some() {
203 insert_json(&mut map, "source_count", self.source_count)?;
204 }
205 if self.is_legal {
206 insert_json(&mut map, "is_legal", self.is_legal)?;
207 }
208 if self.is_manifest {
209 insert_json(&mut map, "is_manifest", self.is_manifest)?;
210 }
211 if self.is_readme {
212 insert_json(&mut map, "is_readme", self.is_readme)?;
213 }
214 if self.is_top_level {
215 insert_json(&mut map, "is_top_level", self.is_top_level)?;
216 }
217 if self.is_key_file {
218 insert_json(&mut map, "is_key_file", self.is_key_file)?;
219 }
220 if self.is_community {
221 insert_json(&mut map, "is_community", self.is_community)?;
222 }
223 if !self.facets.is_empty() {
224 insert_json(&mut map, "facets", &self.facets)?;
225 }
226 if self.tallies.is_some() {
227 insert_json(&mut map, "tallies", &self.tallies)?;
228 }
229
230 map.serialize(serializer)
231 }
232}
233
234impl From<&crate::models::FileInfo> for OutputFileInfo {
235 fn from(value: &crate::models::FileInfo) -> Self {
236 Self {
237 name: value.name.clone(),
238 base_name: value.base_name.clone(),
239 extension: value.extension.clone(),
240 path: value.path.clone(),
241 file_type: value.file_type.clone(),
242 mime_type: value.mime_type.clone(),
243 file_type_label: value.file_type_label.clone(),
244 size: value.size,
245 date: value.date.clone(),
246 sha1: value.sha1.as_ref().map(|d| d.as_hex()),
247 md5: value.md5.as_ref().map(|d| d.as_hex()),
248 sha256: value.sha256.as_ref().map(|d| d.as_hex()),
249 sha1_git: value.sha1_git.as_ref().map(|d| d.as_hex()),
250 programming_language: value.programming_language.clone(),
251 package_data: value
252 .package_data
253 .iter()
254 .map(OutputPackageData::from)
255 .collect(),
256 license_expression: value.license_expression.clone(),
257 license_detections: value
258 .license_detections
259 .iter()
260 .map(OutputLicenseDetection::from)
261 .collect(),
262 license_clues: value.license_clues.iter().map(OutputMatch::from).collect(),
263 percentage_of_license_text: value.percentage_of_license_text,
264 copyrights: value.copyrights.iter().map(OutputCopyright::from).collect(),
265 holders: value.holders.iter().map(OutputHolder::from).collect(),
266 authors: value.authors.iter().map(OutputAuthor::from).collect(),
267 emails: value.emails.iter().map(OutputEmail::from).collect(),
268 urls: value.urls.iter().map(OutputURL::from).collect(),
269 for_packages: value
270 .for_packages
271 .iter()
272 .map(|uid| uid.to_string())
273 .collect(),
274 scan_errors: value.scan_errors.clone(),
275 license_policy: value
276 .license_policy
277 .as_ref()
278 .map(|v| v.iter().map(OutputLicensePolicyEntry::from).collect()),
279 is_generated: value.is_generated,
280 is_binary: value.is_binary,
281 is_text: value.is_text,
282 is_archive: value.is_archive,
283 is_media: value.is_media,
284 is_source: value.is_source,
285 is_script: value.is_script,
286 files_count: value.files_count,
287 dirs_count: value.dirs_count,
288 size_count: value.size_count,
289 source_count: value.source_count,
290 is_legal: value.is_legal,
291 is_manifest: value.is_manifest,
292 is_readme: value.is_readme,
293 is_top_level: value.is_top_level,
294 is_key_file: value.is_key_file,
295 is_community: value.is_community,
296 facets: value.facets.clone(),
297 tallies: value.tallies.as_ref().map(OutputTallies::from),
298 }
299 }
300}
301
302impl TryFrom<&OutputFileInfo> for crate::models::FileInfo {
303 type Error = String;
304 fn try_from(value: &OutputFileInfo) -> Result<Self, Self::Error> {
305 let mut package_data = Vec::with_capacity(value.package_data.len());
306 for p in &value.package_data {
307 package_data.push(crate::models::PackageData::try_from(p)?);
308 }
309 let mut license_detections = Vec::with_capacity(value.license_detections.len());
310 for d in &value.license_detections {
311 license_detections.push(crate::models::LicenseDetection::try_from(d)?);
312 }
313 let mut license_clues = Vec::with_capacity(value.license_clues.len());
314 for m in &value.license_clues {
315 license_clues.push(crate::models::Match::try_from(m)?);
316 }
317 let mut copyrights = Vec::with_capacity(value.copyrights.len());
318 for c in &value.copyrights {
319 copyrights.push(crate::models::Copyright::try_from(c)?);
320 }
321 let mut holders = Vec::with_capacity(value.holders.len());
322 for h in &value.holders {
323 holders.push(crate::models::Holder::try_from(h)?);
324 }
325 let mut authors = Vec::with_capacity(value.authors.len());
326 for a in &value.authors {
327 authors.push(crate::models::Author::try_from(a)?);
328 }
329 let mut emails = Vec::with_capacity(value.emails.len());
330 for e in &value.emails {
331 emails.push(crate::models::OutputEmail::try_from(e)?);
332 }
333 let mut urls = Vec::with_capacity(value.urls.len());
334 for u in &value.urls {
335 urls.push(crate::models::OutputURL::try_from(u)?);
336 }
337 let license_policy = value
338 .license_policy
339 .as_ref()
340 .map(|v| {
341 v.iter()
342 .map(crate::models::LicensePolicyEntry::try_from)
343 .collect::<Result<Vec<_>, _>>()
344 })
345 .transpose()?;
346 Ok(Self {
347 name: value.name.clone(),
348 base_name: value.base_name.clone(),
349 extension: value.extension.clone(),
350 path: value.path.clone(),
351 file_type: value.file_type.clone(),
352 mime_type: value.mime_type.clone(),
353 file_type_label: value.file_type_label.clone(),
354 size: value.size,
355 date: value.date.clone(),
356 sha1: value
357 .sha1
358 .as_ref()
359 .map(|s| crate::models::Sha1Digest::from_hex(s))
360 .transpose()
361 .map_err(|e| format!("invalid sha1: {}", e))?,
362 md5: value
363 .md5
364 .as_ref()
365 .map(|s| crate::models::Md5Digest::from_hex(s))
366 .transpose()
367 .map_err(|e| format!("invalid md5: {}", e))?,
368 sha256: value
369 .sha256
370 .as_ref()
371 .map(|s| crate::models::Sha256Digest::from_hex(s))
372 .transpose()
373 .map_err(|e| format!("invalid sha256: {}", e))?,
374 sha1_git: value
375 .sha1_git
376 .as_ref()
377 .map(|s| crate::models::GitSha1::from_hex(s))
378 .transpose()
379 .map_err(|e| format!("invalid sha1_git: {}", e))?,
380 programming_language: value.programming_language.clone(),
381 package_data,
382 license_expression: value.license_expression.clone(),
383 license_detections,
384 license_clues,
385 percentage_of_license_text: value.percentage_of_license_text,
386 copyrights,
387 holders,
388 authors,
389 emails,
390 urls,
391 for_packages: value
392 .for_packages
393 .iter()
394 .map(|s| crate::models::PackageUid::from_raw(s.clone()))
395 .collect(),
396 scan_errors: value.scan_errors.clone(),
397 license_policy,
398 is_generated: value.is_generated,
399 is_binary: value.is_binary,
400 is_text: value.is_text,
401 is_archive: value.is_archive,
402 is_media: value.is_media,
403 is_source: value.is_source,
404 is_script: value.is_script,
405 files_count: value.files_count,
406 dirs_count: value.dirs_count,
407 size_count: value.size_count,
408 source_count: value.source_count,
409 is_legal: value.is_legal,
410 is_manifest: value.is_manifest,
411 is_readme: value.is_readme,
412 is_top_level: value.is_top_level,
413 is_key_file: value.is_key_file,
414 is_community: value.is_community,
415 facets: value.facets.clone(),
416 tallies: value
417 .tallies
418 .as_ref()
419 .map(crate::models::Tallies::try_from)
420 .transpose()?,
421 })
422 }
423}