feat(cli): scadalink audit query subcommand (#23 M8)

src/ScadaLink.CLI/Commands/AuditExportHelpers.cs

@@ -0,0 +1,114 @@
+using System.Globalization;
+using System.Net;
+
+namespace ScadaLink.CLI.Commands;
+
+/// <summary>
+/// Filter + destination arguments for an <c>audit export</c> invocation. Mirrors the
+/// Bundle B <c>GET /api/audit/export</c> parameters.
+/// </summary>
+public sealed class AuditExportArgs
+{
+    public string Since { get; set; } = string.Empty;
+    public string Until { get; set; } = string.Empty;
+    public string Format { get; set; } = string.Empty;
+    public string Output { get; set; } = string.Empty;
+    public string? Channel { get; set; }
+    public string? Kind { get; set; }
+    public string? Status { get; set; }
+    public string? Site { get; set; }
+    public string? Target { get; set; }
+    public string? Actor { get; set; }
+}
+
+/// <summary>
+/// Helpers for the <c>audit export</c> subcommand: builds the export query string and
+/// streams the HTTP response body straight to the destination file without buffering
+/// the (potentially multi-megabyte) export in memory.
+/// </summary>
+public static class AuditExportHelpers
+{
+    /// <summary>
+    /// Builds the <c>?...</c> query string for <c>GET /api/audit/export</c>: the required
+    /// time window + format, plus optional filters. Time-specs are resolved via
+    /// <see cref="AuditQueryHelpers.ResolveTimeSpec"/>.
+    /// </summary>
+    public static string BuildQueryString(AuditExportArgs args, DateTimeOffset now)
+    {
+        var parts = new List<string>();
+
+        void Add(string key, string? value)
+        {
+            if (!string.IsNullOrWhiteSpace(value))
+                parts.Add($"{key}={Uri.EscapeDataString(value)}");
+        }
+
+        Add("fromUtc", AuditQueryHelpers.ResolveTimeSpec(args.Since, now).ToString("o", CultureInfo.InvariantCulture));
+        Add("toUtc", AuditQueryHelpers.ResolveTimeSpec(args.Until, now).ToString("o", CultureInfo.InvariantCulture));
+        Add("format", args.Format);
+        Add("channel", args.Channel);
+        Add("kind", args.Kind);
+        Add("status", args.Status);
+        Add("sourceSiteId", args.Site);
+        Add("target", args.Target);
+        Add("actor", args.Actor);
+
+        return "?" + string.Join("&", parts);
+    }
+
+    /// <summary>
+    /// Executes the export: GETs <c>/api/audit/export</c> and copies the response body
+    /// stream directly to <see cref="AuditExportArgs.Output"/>. The body is never fully
+    /// buffered — <see cref="Stream.CopyToAsync(Stream)"/> streams in fixed-size chunks.
+    /// A <c>501 Not Implemented</c> (parquet not yet supported server-side) prints the
+    /// server message and returns a non-zero exit code.
+    /// </summary>
+    public static async Task<int> RunExportAsync(
+        ManagementHttpClient client, AuditExportArgs args, TextWriter output, DateTimeOffset now)
+    {
+        var qs = BuildQueryString(args, now);
+
+        HttpResponseMessage response;
+        try
+        {
+            response = await client.SendGetStreamAsync("api/audit/export" + qs, CancellationToken.None);
+        }
+        catch (HttpRequestException ex)
+        {
+            OutputFormatter.WriteError($"Connection failed: {ex.Message}", "CONNECTION_FAILED");
+            return 1;
+        }
+
+        using (response)
+        {
+            if (response.StatusCode == HttpStatusCode.NotImplemented)
+            {
+                var message = await response.Content.ReadAsStringAsync();
+                OutputFormatter.WriteError(
+                    string.IsNullOrWhiteSpace(message)
+                        ? "Export format not implemented by the server."
+                        : message,
+                    "NOT_IMPLEMENTED");
+                return 1;
+            }
+
+            if (!response.IsSuccessStatusCode)
+            {
+                var message = await response.Content.ReadAsStringAsync();
+                OutputFormatter.WriteError(
+                    string.IsNullOrWhiteSpace(message) ? $"Export failed (HTTP {(int)response.StatusCode})." : message,
+                    "ERROR");
+                return 1;
+            }
+
+            await using var source = await response.Content.ReadAsStreamAsync();
+            await using var destination = new FileStream(
+                args.Output, FileMode.Create, FileAccess.Write, FileShare.None,
+                bufferSize: 81920, useAsync: true);
+            await source.CopyToAsync(destination);
+        }
+
+        output.WriteLine($"Exported audit log to {args.Output}");
+        return 0;
+    }
+}