1use std::collections::BTreeSet;
2
3use chrono::{DateTime, Utc};
4
5use super::models::*;
6
7const STALLED_WORKLOAD_SECONDS: i64 = 15 * 60;
8
9pub fn derive_findings(snapshot: &EspDiagnosticsSnapshot) -> Vec<EspDiagnosticFinding> {
15 let mut findings = Vec::new();
16
17 push_failed_blocking_app(snapshot, &mut findings);
18 push_stalled_workload(snapshot, &mut findings);
19 push_esp_timeout(snapshot, &mut findings);
20 push_failed_registration(snapshot, &mut findings);
21 push_unprocessed_workloads(snapshot, &mut findings);
22 push_ime_coverage_gap(snapshot, &mut findings);
23 push_non_elevated_coverage_loss(snapshot, &mut findings);
24 push_ambiguous_installer(snapshot, &mut findings);
25 push_local_graph_conflict(snapshot, &mut findings);
26 push_malformed_source(snapshot, &mut findings);
27 push_successful_completion(snapshot, &mut findings);
28
29 findings
30}
31
32pub fn attach_graph_overlay(
35 snapshot: &EspDiagnosticsSnapshot,
36 graph: EspGraphOverlay,
37) -> EspDiagnosticsSnapshot {
38 let mut projected = snapshot.clone();
39 projected.graph = Some(graph);
40 projected.findings = derive_findings(&projected);
41 projected
42}
43
44fn push_failed_blocking_app(
45 snapshot: &EspDiagnosticsSnapshot,
46 findings: &mut Vec<EspDiagnosticFinding>,
47) {
48 let failed = current_workloads(snapshot)
49 .filter(|workload| {
50 is_app_kind(&workload.kind)
51 && workload.status.normalized == EspNormalizedStatus::Failed
52 && workload.blocking != Some(false)
56 })
57 .collect::<Vec<_>>();
58 if failed.is_empty() {
59 return;
60 }
61 let summary = format!(
62 "{} failed during setup: {}.",
63 if failed.len() == 1 {
64 "An application"
65 } else {
66 "Applications"
67 },
68 failed_app_labels(&failed),
69 );
70 let evidence = collect_evidence(failed.iter().flat_map(|workload| workload.evidence.iter()));
71 push_finding(
72 findings,
73 finding(
74 "blocking-app-failed",
75 EspFindingSeverity::Blocker,
76 EspFindingConfidence::High,
77 "An application failed during setup",
78 &summary,
79 "Inspect the named app's cited IME or deployment log around its final failure for the exit/enforcement code.",
80 evidence,
81 vec![],
82 ),
83 );
84}
85
86fn failed_app_labels(workloads: &[&EspWorkload]) -> String {
89 const MAX_LABELS: usize = 6;
90 let mut labels: Vec<String> = Vec::new();
91 for workload in workloads {
92 let label = workload
93 .display_name
94 .clone()
95 .unwrap_or_else(|| workload.raw_identifier.clone());
96 if !labels.contains(&label) {
97 labels.push(label);
98 }
99 }
100 let extra = labels.len().saturating_sub(MAX_LABELS);
101 labels.truncate(MAX_LABELS);
102 let mut joined = labels.join(", ");
103 if extra > 0 {
104 joined.push_str(&format!(" (+{extra} more)"));
105 }
106 joined
107}
108
109fn push_stalled_workload(
110 snapshot: &EspDiagnosticsSnapshot,
111 findings: &mut Vec<EspDiagnosticFinding>,
112) {
113 let Some(generated_at) = parse_rfc3339(&snapshot.generated_at_utc) else {
114 return;
115 };
116 let workloads = current_workloads(snapshot).filter(|workload| {
117 if !matches!(
118 workload.status.normalized,
119 EspNormalizedStatus::Downloading
120 | EspNormalizedStatus::Installing
121 | EspNormalizedStatus::InProgress
122 ) {
123 return false;
124 }
125 workload
126 .timestamps
127 .last_updated
128 .as_ref()
129 .or(workload.timestamps.started.as_ref())
130 .and_then(normalized_timestamp)
131 .is_some_and(|updated| {
132 generated_at.signed_duration_since(updated).num_seconds()
133 >= STALLED_WORKLOAD_SECONDS
134 })
135 });
136 let evidence = collect_evidence(workloads.flat_map(|workload| workload.evidence.iter()));
137 push_finding(
138 findings,
139 finding(
140 "workload-stalled",
141 EspFindingSeverity::Error,
142 EspFindingConfidence::High,
143 "A download or installation has stopped updating",
144 "A workload remains active and its cited last-update timestamp is at least 15 minutes old.",
145 "Compare the cited workload's last update with IME and Delivery Optimization activity.",
146 evidence,
147 vec![],
148 ),
149 );
150}
151
152fn push_esp_timeout(snapshot: &EspDiagnosticsSnapshot, findings: &mut Vec<EspDiagnosticFinding>) {
153 if snapshot.phase == EspPhase::Completed {
154 return;
155 }
156 let Some(generated_at) = parse_rfc3339(&snapshot.generated_at_utc) else {
157 return;
158 };
159 let timeout_values = snapshot
160 .enrollments
161 .iter()
162 .filter_map(|enrollment| enrollment.settings.timeout_seconds)
163 .filter(|timeout| *timeout > 0)
164 .collect::<BTreeSet<_>>();
165 if timeout_values.len() != 1 {
166 return;
167 }
168 let Some(timeout_seconds) = timeout_values.iter().next().copied() else {
169 return;
170 };
171 let Ok(timeout_seconds_i64) = i64::try_from(timeout_seconds) else {
172 return;
173 };
174 let timed_out_sessions = snapshot.sessions.iter().filter(|session| {
175 session.is_latest
176 && !matches!(session.phase, EspPhase::Completed)
177 && session
178 .started_at
179 .as_ref()
180 .and_then(normalized_timestamp)
181 .is_some_and(|started| {
182 generated_at.signed_duration_since(started).num_seconds() >= timeout_seconds_i64
183 })
184 });
185 let mut evidence =
186 collect_evidence(timed_out_sessions.flat_map(|session| session.evidence.iter()));
187 if evidence.is_empty() {
188 return;
189 }
190 evidence.extend(collect_evidence(
191 snapshot
192 .enrollments
193 .iter()
194 .filter(|enrollment| enrollment.settings.timeout_seconds == Some(timeout_seconds))
195 .flat_map(|enrollment| enrollment.evidence.iter()),
196 ));
197 normalize_evidence(&mut evidence);
198 push_finding(
199 findings,
200 finding(
201 "esp-timeout-reached",
202 EspFindingSeverity::Blocker,
203 EspFindingConfidence::High,
204 "The configured ESP timeout has been reached",
205 "The current time is beyond the configured timeout for a cited active ESP session.",
206 "Compare the cited ESP session start time with the configured timeout.",
207 evidence,
208 vec![],
209 ),
210 );
211}
212
213fn push_failed_registration(
214 snapshot: &EspDiagnosticsSnapshot,
215 findings: &mut Vec<EspDiagnosticFinding>,
216) {
217 let events = snapshot.registration_events.iter().filter(|event| {
218 event.status.normalized == EspNormalizedStatus::Failed && event.event_id == 304
219 });
220 let mut evidence = collect_evidence(events.flat_map(|event| event.evidence.iter()));
221 evidence.extend(collect_evidence(
222 snapshot
223 .activity
224 .iter()
225 .filter(|entry| {
226 entry.kind == EspTimelineKind::OfflineDomainJoin
227 && entry
228 .status
229 .as_ref()
230 .is_some_and(|status| status.normalized == EspNormalizedStatus::Failed)
231 })
232 .flat_map(|entry| entry.evidence.iter()),
233 ));
234 normalize_evidence(&mut evidence);
235 push_finding(
236 findings,
237 finding(
238 "registration-or-join-failed",
239 EspFindingSeverity::Error,
240 EspFindingConfidence::High,
241 "Device registration or join failed",
242 "A cited device-registration or Offline Domain Join event has an explicit failed status.",
243 "Inspect the cited Device Registration or Offline Domain Join event and its named data.",
244 evidence,
245 vec![],
246 ),
247 );
248}
249
250fn push_unprocessed_workloads(
251 snapshot: &EspDiagnosticsSnapshot,
252 findings: &mut Vec<EspDiagnosticFinding>,
253) {
254 push_unprocessed_kind(
255 snapshot,
256 findings,
257 EspTrackedKind::Policy,
258 "policy-not-processed",
259 "A tracked policy has not been processed",
260 "At least one cited policy remains in a pre-processing state.",
261 "Inspect the cited policy tracking state and enrollment scope.",
262 );
263 push_unprocessed_kind(
264 snapshot,
265 findings,
266 EspTrackedKind::ScepCertificate,
267 "certificate-not-processed",
268 "A tracked certificate has not been processed",
269 "At least one cited certificate remains in a pre-processing state.",
270 "Inspect the cited certificate tracking state and enrollment scope.",
271 );
272}
273
274#[allow(clippy::too_many_arguments)]
275fn push_unprocessed_kind(
276 snapshot: &EspDiagnosticsSnapshot,
277 findings: &mut Vec<EspDiagnosticFinding>,
278 kind: EspTrackedKind,
279 id: &str,
280 title: &str,
281 summary: &str,
282 check: &str,
283) {
284 let workloads = current_workloads(snapshot)
285 .filter(|workload| workload.kind == kind && is_not_processed(&workload.status.normalized));
286 let evidence = collect_evidence(workloads.flat_map(|workload| workload.evidence.iter()));
287 push_finding(
288 findings,
289 finding(
290 id,
291 EspFindingSeverity::Warning,
292 EspFindingConfidence::High,
293 title,
294 summary,
295 check,
296 evidence,
297 vec![],
298 ),
299 );
300}
301
302fn push_ime_coverage_gap(
303 snapshot: &EspDiagnosticsSnapshot,
304 findings: &mut Vec<EspDiagnosticFinding>,
305) {
306 let coverage = snapshot.coverage.iter().filter(|coverage| {
307 is_ime_log_coverage(coverage)
308 && matches!(
309 coverage.status,
310 EspArtifactStatus::Missing | EspArtifactStatus::PermissionDenied
311 )
312 });
313 let entries = coverage.collect::<Vec<_>>();
314 let evidence = collect_evidence(entries.iter().flat_map(|coverage| coverage.evidence.iter()));
315 let gaps = collect_gap_ids(entries.iter().map(|coverage| coverage.artifact_id.as_str()));
316 push_finding(
317 findings,
318 finding(
319 "ime-evidence-unavailable",
320 EspFindingSeverity::Warning,
321 EspFindingConfidence::High,
322 "IME evidence is unavailable",
323 "The source inventory explicitly reports missing or unreadable Intune Management Extension logs.",
324 "Open the cited IME coverage entry and verify the protected log path is readable.",
325 evidence,
326 gaps,
327 ),
328 );
329}
330
331fn is_ime_log_coverage(coverage: &EspArtifactCoverage) -> bool {
332 let artifact = normalize_source_identity(&coverage.artifact_id);
333 let family = normalize_source_identity(&coverage.family);
334 matches!(
335 artifact.as_str(),
336 "imelogs"
337 | "intuneimelogs"
338 | "windowsintuneimelogs"
339 | "intunemanagementextensionlog"
340 | "intunemanagementextensionlogs"
341 ) || matches!(
342 family.as_str(),
343 "intuneime" | "intunemanagementextension" | "intunemanagementextensionlogs"
344 )
345}
346
347fn normalize_source_identity(value: &str) -> String {
348 value
349 .chars()
350 .filter(|character| character.is_ascii_alphanumeric())
351 .flat_map(char::to_lowercase)
352 .collect()
353}
354
355fn push_non_elevated_coverage_loss(
356 snapshot: &EspDiagnosticsSnapshot,
357 findings: &mut Vec<EspDiagnosticFinding>,
358) {
359 if snapshot.elevation.is_elevated {
360 return;
361 }
362 let denied = snapshot
363 .coverage
364 .iter()
365 .filter(|coverage| coverage.status == EspArtifactStatus::PermissionDenied)
366 .collect::<Vec<_>>();
367 let evidence = collect_evidence(denied.iter().flat_map(|coverage| coverage.evidence.iter()));
368 let gaps = collect_gap_ids(
369 denied
370 .iter()
371 .map(|coverage| coverage.artifact_id.as_str())
372 .chain(
373 snapshot
374 .elevation
375 .restricted_sources
376 .iter()
377 .map(String::as_str),
378 ),
379 );
380 push_finding(
381 findings,
382 finding(
383 "non-elevated-coverage-loss",
384 EspFindingSeverity::Warning,
385 EspFindingConfidence::High,
386 "Non-elevated access is hiding diagnostic evidence",
387 "The session is not elevated and one or more protected evidence sources are unavailable.",
388 "Review the cited coverage gaps, then relaunch CMTrace Open as administrator if deeper evidence is required.",
389 evidence,
390 gaps,
391 ),
392 );
393}
394
395fn push_ambiguous_installer(
396 snapshot: &EspDiagnosticsSnapshot,
397 findings: &mut Vec<EspDiagnosticFinding>,
398) {
399 let correlations = snapshot
400 .installer_correlations
401 .iter()
402 .filter(|correlation| {
403 correlation.workload_id.is_none()
404 && correlation.confidence == EspCorrelationConfidence::Uncorrelated
405 && correlation.candidate_workload_ids.len() > 1
406 });
407 let evidence =
408 collect_evidence(correlations.flat_map(|correlation| correlation.evidence.iter()));
409 push_finding(
410 findings,
411 finding(
412 "installer-correlation-ambiguous",
413 EspFindingSeverity::Warning,
414 EspFindingConfidence::Medium,
415 "The active installer cannot be matched to one workload",
416 "Multiple candidate workloads remain after the available installer evidence is compared.",
417 "Compare the cited process start time, log path, app ID, and product code with each candidate workload.",
418 evidence,
419 vec![],
420 ),
421 );
422}
423
424fn push_local_graph_conflict(
425 snapshot: &EspDiagnosticsSnapshot,
426 findings: &mut Vec<EspDiagnosticFinding>,
427) {
428 let Some(graph) = &snapshot.graph else {
429 return;
430 };
431 let mut evidence = Vec::new();
432
433 if graph.apps.status == GraphSectionStatus::Available {
434 if let Some(apps) = &graph.apps.data {
435 for workload in current_workloads(snapshot).filter(|workload| {
436 !workload.raw_identifier.trim().is_empty() && is_app_kind(&workload.kind)
437 }) {
438 for app in apps
439 .iter()
440 .filter(|app| app.app_id.eq_ignore_ascii_case(&workload.raw_identifier))
441 {
442 extend_status_conflict_evidence(
443 &mut evidence,
444 workload,
445 app.status.as_ref(),
446 &app.evidence,
447 );
448 }
449 }
450 }
451 }
452 if graph.policies.status == GraphSectionStatus::Available {
453 if let Some(policies) = &graph.policies.data {
454 for workload in current_workloads(snapshot).filter(|workload| {
455 !workload.raw_identifier.trim().is_empty()
456 && matches!(
457 workload.kind,
458 EspTrackedKind::Policy | EspTrackedKind::ScepCertificate
459 )
460 }) {
461 for policy in policies.iter().filter(|policy| {
462 policy
463 .policy_id
464 .eq_ignore_ascii_case(&workload.raw_identifier)
465 }) {
466 extend_status_conflict_evidence(
467 &mut evidence,
468 workload,
469 policy.status.as_ref(),
470 &policy.evidence,
471 );
472 }
473 }
474 }
475 }
476 if graph.scripts.status == GraphSectionStatus::Available {
477 if let Some(scripts) = &graph.scripts.data {
478 for workload in current_workloads(snapshot).filter(|workload| {
479 !workload.raw_identifier.trim().is_empty()
480 && workload.kind == EspTrackedKind::PlatformScript
481 }) {
482 for script in scripts.iter().filter(|script| {
483 script
484 .script_id
485 .eq_ignore_ascii_case(&workload.raw_identifier)
486 }) {
487 extend_status_conflict_evidence(
488 &mut evidence,
489 workload,
490 script.status.as_ref(),
491 &script.evidence,
492 );
493 }
494 }
495 }
496 }
497 normalize_evidence(&mut evidence);
498 push_finding(
499 findings,
500 finding(
501 "local-graph-state-conflict",
502 EspFindingSeverity::Warning,
503 EspFindingConfidence::High,
504 "Local and Intune Graph workload states disagree",
505 "The same exact workload identifier has contradictory explicit terminal states in local evidence and Intune Graph.",
506 "Compare the cited local workload state with the current Intune Graph status.",
507 evidence,
508 vec![],
509 ),
510 );
511}
512
513fn extend_status_conflict_evidence(
514 evidence: &mut Vec<EspEvidenceRef>,
515 workload: &EspWorkload,
516 graph_status: Option<&EspStatus>,
517 graph_evidence: &[EspEvidenceRef],
518) {
519 let Some(graph_status) = graph_status else {
520 return;
521 };
522 if workload.evidence.is_empty()
523 || graph_evidence.is_empty()
524 || !statuses_contradict(&workload.status.normalized, &graph_status.normalized)
525 {
526 return;
527 }
528 evidence.extend(workload.evidence.iter().cloned());
529 evidence.extend(graph_evidence.iter().cloned());
530}
531
532fn statuses_contradict(local: &EspNormalizedStatus, remote: &EspNormalizedStatus) -> bool {
533 (is_unsuccessful_terminal_status(local) && is_successful_terminal_status(remote))
534 || (is_unsuccessful_terminal_status(remote) && is_successful_terminal_status(local))
535}
536
537fn push_malformed_source(
538 snapshot: &EspDiagnosticsSnapshot,
539 findings: &mut Vec<EspDiagnosticFinding>,
540) {
541 let malformed_coverage = snapshot
542 .coverage
543 .iter()
544 .filter(|coverage| coverage.status == EspArtifactStatus::ParseFailed)
545 .collect::<Vec<_>>();
546 let mut evidence = collect_evidence(
547 malformed_coverage
548 .iter()
549 .flat_map(|coverage| coverage.evidence.iter())
550 .chain(
551 snapshot
552 .raw_evidence
553 .iter()
554 .filter(|raw| raw.parse_state == EspParseState::Malformed)
555 .flat_map(|raw| raw.evidence.iter()),
556 ),
557 );
558 normalize_evidence(&mut evidence);
559 let gaps = collect_gap_ids(
560 malformed_coverage
561 .iter()
562 .map(|coverage| coverage.artifact_id.as_str()),
563 );
564 push_finding(
565 findings,
566 finding(
567 "source-evidence-malformed",
568 EspFindingSeverity::Warning,
569 EspFindingConfidence::High,
570 "A diagnostic source is malformed",
571 "At least one cited diagnostic source failed parsing.",
572 "Inspect the cited source coverage and any available raw evidence.",
573 evidence,
574 gaps,
575 ),
576 );
577}
578
579fn push_successful_completion(
580 snapshot: &EspDiagnosticsSnapshot,
581 findings: &mut Vec<EspDiagnosticFinding>,
582) {
583 if snapshot.phase != EspPhase::Completed {
584 return;
585 }
586 let latest_sessions = snapshot
587 .sessions
588 .iter()
589 .filter(|session| session.is_latest)
590 .collect::<Vec<_>>();
591 if latest_sessions.is_empty()
592 || latest_sessions
593 .iter()
594 .any(|session| session.phase != EspPhase::Completed || session.workload_ids.is_empty())
595 {
596 return;
597 }
598
599 let mut evidence = collect_evidence(
600 latest_sessions
601 .iter()
602 .flat_map(|session| session.evidence.iter()),
603 );
604 let mut supporting_source_ids = evidence
605 .iter()
606 .filter(|evidence| !evidence.source_artifact_id.trim().is_empty())
607 .map(|evidence| evidence.source_artifact_id.clone())
608 .collect::<BTreeSet<_>>();
609 for session in &latest_sessions {
610 for workload_id in &session.workload_ids {
611 let Some(workload) = snapshot.workloads.iter().find(|workload| {
612 workload.session_id == session.session_id && &workload.workload_id == workload_id
613 }) else {
614 return;
615 };
616 if !is_successful_terminal_status(&workload.status.normalized) {
617 return;
618 }
619 supporting_source_ids.extend(
620 workload
621 .evidence
622 .iter()
623 .filter(|evidence| !evidence.source_artifact_id.trim().is_empty())
624 .map(|evidence| evidence.source_artifact_id.clone()),
625 );
626 evidence.extend(workload.evidence.iter().cloned());
627 }
628 }
629 if evidence.is_empty() {
630 return;
631 }
632 if supporting_source_ids.is_empty() {
633 return;
634 }
635 for source_artifact_id in supporting_source_ids {
636 let mut relevant_coverage = snapshot.coverage.iter().filter(|coverage| {
637 coverage.artifact_id == source_artifact_id
638 || coverage
639 .evidence
640 .iter()
641 .any(|evidence| evidence.source_artifact_id == source_artifact_id)
642 });
643 let Some(first_coverage) = relevant_coverage.next() else {
644 return;
645 };
646 if first_coverage.status != EspArtifactStatus::Available
647 || relevant_coverage.any(|coverage| coverage.status != EspArtifactStatus::Available)
648 {
649 return;
650 }
651 }
652 normalize_evidence(&mut evidence);
653 push_finding(
654 findings,
655 finding(
656 "esp-completed",
657 EspFindingSeverity::Info,
658 EspFindingConfidence::High,
659 "ESP completed successfully",
660 "The cited latest session completed and every declared workload was observed in a successful terminal state.",
661 "Review the cited completed session and terminal workload states.",
662 evidence,
663 vec![],
664 ),
665 );
666}
667
668#[allow(clippy::too_many_arguments)]
669fn finding(
670 id: &str,
671 severity: EspFindingSeverity,
672 confidence: EspFindingConfidence,
673 title: &str,
674 summary: &str,
675 check: &str,
676 evidence: Vec<EspEvidenceRef>,
677 coverage_gap_ids: Vec<String>,
678) -> Option<EspDiagnosticFinding> {
679 if evidence.is_empty() && coverage_gap_ids.is_empty() {
680 return None;
681 }
682 Some(EspDiagnosticFinding {
683 finding_id: id.to_string(),
684 severity,
685 confidence,
686 title: title.to_string(),
687 summary: summary.to_string(),
688 recommended_checks: vec![check.to_string()],
689 evidence,
690 coverage_gap_ids,
691 })
692}
693
694fn push_finding(findings: &mut Vec<EspDiagnosticFinding>, finding: Option<EspDiagnosticFinding>) {
695 if let Some(finding) = finding {
696 findings.push(finding);
697 }
698}
699
700fn is_app_kind(kind: &EspTrackedKind) -> bool {
701 matches!(
702 kind,
703 EspTrackedKind::Msi
704 | EspTrackedKind::Office
705 | EspTrackedKind::ModernApp
706 | EspTrackedKind::Win32App
707 | EspTrackedKind::DevicePreparationWorkload
708 )
709}
710
711fn is_not_processed(status: &EspNormalizedStatus) -> bool {
712 matches!(
713 status,
714 EspNormalizedStatus::NotStarted
715 | EspNormalizedStatus::NotInstalled
716 | EspNormalizedStatus::Initialized
717 | EspNormalizedStatus::Pending
718 )
719}
720
721fn is_successful_terminal_status(status: &EspNormalizedStatus) -> bool {
722 matches!(
723 status,
724 EspNormalizedStatus::Succeeded
725 | EspNormalizedStatus::Processed
726 | EspNormalizedStatus::Skipped
727 | EspNormalizedStatus::Uninstalled
728 )
729}
730
731fn is_unsuccessful_terminal_status(status: &EspNormalizedStatus) -> bool {
732 matches!(
733 status,
734 EspNormalizedStatus::Failed | EspNormalizedStatus::Cancelled
735 )
736}
737
738fn current_workloads(snapshot: &EspDiagnosticsSnapshot) -> impl Iterator<Item = &EspWorkload> {
739 let sessionless = snapshot.sessions.is_empty();
740 let latest_workload_keys = snapshot
741 .sessions
742 .iter()
743 .filter(|session| session.is_latest)
744 .flat_map(|session| {
745 session
746 .workload_ids
747 .iter()
748 .map(move |workload_id| (session.session_id.as_str(), workload_id.as_str()))
749 })
750 .collect::<BTreeSet<_>>();
751
752 snapshot.workloads.iter().filter(move |workload| {
753 sessionless
754 || latest_workload_keys
755 .contains(&(workload.session_id.as_str(), workload.workload_id.as_str()))
756 })
757}
758
759fn normalized_timestamp(timestamp: &EspTimestamp) -> Option<DateTime<Utc>> {
760 timestamp.normalized_utc.as_deref().and_then(parse_rfc3339)
761}
762
763fn parse_rfc3339(value: &str) -> Option<DateTime<Utc>> {
764 DateTime::parse_from_rfc3339(value)
765 .ok()
766 .map(|value| value.with_timezone(&Utc))
767}
768
769fn collect_evidence<'a>(
770 evidence: impl IntoIterator<Item = &'a EspEvidenceRef>,
771) -> Vec<EspEvidenceRef> {
772 let mut collected = evidence.into_iter().cloned().collect::<Vec<_>>();
773 normalize_evidence(&mut collected);
774 collected
775}
776
777fn normalize_evidence(evidence: &mut Vec<EspEvidenceRef>) {
778 evidence.sort_by(|left, right| {
779 left.evidence_id
780 .cmp(&right.evidence_id)
781 .then_with(|| left.source_artifact_id.cmp(&right.source_artifact_id))
782 });
783 evidence.dedup_by(|left, right| {
784 left.evidence_id == right.evidence_id && left.source_artifact_id == right.source_artifact_id
785 });
786}
787
788fn collect_gap_ids<'a>(gaps: impl IntoIterator<Item = &'a str>) -> Vec<String> {
789 let mut gaps = gaps
790 .into_iter()
791 .filter(|gap| !gap.trim().is_empty())
792 .map(str::to_string)
793 .collect::<Vec<_>>();
794 gaps.sort();
795 gaps.dedup();
796 gaps
797}