up

src/Scanner/StellaOps.Scanner.WebService/Services/LinksetResolver.cs

@@ -0,0 +1,181 @@
+using System.Collections.Immutable;
+using System.Globalization;
+using Microsoft.Extensions.Logging;
+using StellaOps.Concelier.Core.Linksets;
+using StellaOps.Scanner.Surface.Env;
+using StellaOps.Scanner.WebService.Contracts;
+
+namespace StellaOps.Scanner.WebService.Services;
+
+internal interface ILinksetResolver
+{
+    Task<IReadOnlyList<LinksetSummaryDto>> ResolveAsync(IEnumerable<PolicyPreviewFindingDto>? findings, CancellationToken cancellationToken);
+    Task<IReadOnlyList<LinksetSummaryDto>> ResolveAsync(IEnumerable<StellaOps.Policy.PolicyVerdict> verdicts, CancellationToken cancellationToken);
+    Task<IReadOnlyList<LinksetSummaryDto>> ResolveByAdvisoryIdsAsync(IEnumerable<string> advisoryIds, CancellationToken cancellationToken);
+}
+
+internal sealed class LinksetResolver : ILinksetResolver
+{
+    private readonly IAdvisoryLinksetQueryService _queryService;
+    private readonly ISurfaceEnvironment _surfaceEnvironment;
+    private readonly ILogger<LinksetResolver> _logger;
+
+    public LinksetResolver(
+        IAdvisoryLinksetQueryService queryService,
+        ISurfaceEnvironment surfaceEnvironment,
+        ILogger<LinksetResolver> logger)
+    {
+        _queryService = queryService ?? throw new ArgumentNullException(nameof(queryService));
+        _surfaceEnvironment = surfaceEnvironment ?? throw new ArgumentNullException(nameof(surfaceEnvironment));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    public Task<IReadOnlyList<LinksetSummaryDto>> ResolveAsync(IEnumerable<PolicyPreviewFindingDto>? findings, CancellationToken cancellationToken)
+    {
+        var advisoryIds = findings?
+            .SelectMany(f => new[] { f?.Id, f?.Cve })
+            .Where(id => !string.IsNullOrWhiteSpace(id))
+            .Select(id => id!.Trim())
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray() ?? Array.Empty<string>();
+
+        return ResolveInternalAsync(advisoryIds, cancellationToken);
+    }
+
+    public Task<IReadOnlyList<LinksetSummaryDto>> ResolveAsync(IEnumerable<StellaOps.Policy.PolicyVerdict> verdicts, CancellationToken cancellationToken)
+    {
+        var advisoryIds = verdicts?
+            .Where(v => !string.IsNullOrWhiteSpace(v.FindingId))
+            .Select(v => v.FindingId!.Trim())
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray() ?? Array.Empty<string>();
+
+        return ResolveInternalAsync(advisoryIds, cancellationToken);
+    }
+
+    public Task<IReadOnlyList<LinksetSummaryDto>> ResolveByAdvisoryIdsAsync(IEnumerable<string> advisoryIds, CancellationToken cancellationToken)
+    {
+        var normalized = advisoryIds?
+            .Where(id => !string.IsNullOrWhiteSpace(id))
+            .Select(id => id.Trim())
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToArray() ?? Array.Empty<string>();
+
+        return ResolveInternalAsync(normalized, cancellationToken);
+    }
+
+    private async Task<IReadOnlyList<LinksetSummaryDto>> ResolveInternalAsync(IReadOnlyList<string> advisoryIds, CancellationToken cancellationToken)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (advisoryIds.Count == 0)
+        {
+            return Array.Empty<LinksetSummaryDto>();
+        }
+
+        var tenant = string.IsNullOrWhiteSpace(_surfaceEnvironment.Settings.Tenant)
+            ? "default"
+            : _surfaceEnvironment.Settings.Tenant.Trim();
+
+        try
+        {
+            var options = new AdvisoryLinksetQueryOptions(tenant, advisoryIds, Sources: null, Limit: advisoryIds.Count);
+            var result = await _queryService.QueryAsync(options, cancellationToken).ConfigureAwait(false);
+
+            if (result.Linksets.IsDefaultOrEmpty)
+            {
+                return Array.Empty<LinksetSummaryDto>();
+            }
+
+            return result.Linksets
+                .Select(MapSummary)
+                .OrderBy(ls => ls.AdvisoryId, StringComparer.Ordinal)
+                .ToArray();
+        }
+        catch (Exception ex) when (!cancellationToken.IsCancellationRequested)
+        {
+            _logger.LogWarning(ex, "Failed to resolve linksets for {Count} advisories (tenant={Tenant}).", advisoryIds.Count, tenant);
+            return Array.Empty<LinksetSummaryDto>();
+        }
+    }
+
+    private static LinksetSummaryDto MapSummary(AdvisoryLinkset linkset)
+    {
+        var severities = linkset.Normalized?.Severities?.Select(MapSeverity).ToArray();
+        var conflicts = linkset.Conflicts?.Select(MapConflict).ToArray();
+
+        return new LinksetSummaryDto
+        {
+            AdvisoryId = linkset.AdvisoryId,
+            Source = linkset.Source,
+            Confidence = linkset.Confidence,
+            ObservationIds = linkset.ObservationIds.Length > 0 ? linkset.ObservationIds : null,
+            References = null,
+            Severities = severities?.Length > 0 ? severities : null,
+            Conflicts = conflicts?.Length > 0 ? conflicts : null
+        };
+    }
+
+    private static LinksetSeverityDto MapSeverity(Dictionary<string, object?> payload)
+    {
+        payload ??= new Dictionary<string, object?>(StringComparer.Ordinal);
+
+        string? GetString(string key)
+            => payload.TryGetValue(key, out var value) ? value?.ToString() : null;
+
+        double? GetDouble(string key)
+        {
+            if (!payload.TryGetValue(key, out var value) || value is null)
+            {
+                return null;
+            }
+
+            if (value is double d)
+            {
+                return d;
+            }
+
+            if (value is float f)
+            {
+                return Convert.ToDouble(f, CultureInfo.InvariantCulture);
+            }
+
+            if (double.TryParse(value.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out var parsed))
+            {
+                return parsed;
+            }
+
+            return null;
+        }
+
+        var labels = payload.TryGetValue("labels", out var labelsValue) && labelsValue is Dictionary<string, object?> labelsDict
+            ? labelsDict.ToDictionary(kv => kv.Key, kv => kv.Value?.ToString() ?? string.Empty, StringComparer.Ordinal)
+            : null;
+
+        var raw = payload.Count == 0
+            ? null
+            : payload.ToDictionary(kv => kv.Key, kv => kv.Value, StringComparer.Ordinal);
+
+        return new LinksetSeverityDto
+        {
+            Source = GetString("source"),
+            Type = GetString("type"),
+            Score = GetDouble("score"),
+            Vector = GetString("vector"),
+            Origin = GetString("origin"),
+            Labels = labels,
+            Raw = raw
+        };
+    }
+
+    private static LinksetConflictDto MapConflict(AdvisoryLinksetConflict conflict)
+    {
+        return new LinksetConflictDto
+        {
+            Field = conflict.Field,
+            Reason = conflict.Reason,
+            Values = conflict.Values,
+            SourceIds = conflict.SourceIds
+        };
+    }
+}