445 lines
16 KiB
C#
445 lines
16 KiB
C#
using System.Text.Json;
|
|
using Microsoft.AspNetCore.Components;
|
|
using Microsoft.JSInterop;
|
|
using ScadaLink.Commons.Entities.Audit;
|
|
using ScadaLink.Commons.Types.Audit;
|
|
using ScadaLink.Commons.Types.Enums;
|
|
|
|
namespace ScadaLink.CentralUI.Components.Audit;
|
|
|
|
/// <summary>
|
|
/// Keyset-paged results grid for the central Audit Log page (#23 M7-T3).
|
|
/// Renders the columns named in Component-AuditLog.md §10 — OccurredAtUtc,
|
|
/// Site, Channel, Kind, Status, Target, Actor, DurationMs, HttpStatus,
|
|
/// ErrorMessage — plus the ExecutionId per-run correlation column. Talks to
|
|
/// <see cref="Services.IAuditLogQueryService"/>
|
|
/// — never to <c>IAuditLogRepository</c> directly — so tests can stub the data
|
|
/// source without standing up EF Core.
|
|
///
|
|
/// <para>
|
|
/// <b>Column model.</b> Each column has a stable string key. The default
|
|
/// visible order is the <see cref="ColumnOrder"/> parameter (or the spec
|
|
/// order from Component-AuditLog.md §10 when the parameter is null). On top of
|
|
/// that default the grid layers a per-browser override: drag-to-reorder and
|
|
/// drag-to-resize UX (audit-grid.js) writes the chosen order + per-column
|
|
/// widths to <c>sessionStorage</c>, and the grid restores them on first
|
|
/// render. A stored order that names an unknown/removed column degrades
|
|
/// gracefully — unknown keys are dropped, missing columns appended in default
|
|
/// order — so it never throws.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// <b>Pagination.</b> Each page is a single call to
|
|
/// <c>IAuditLogQueryService.QueryAsync</c>. The "Next page" button uses the
|
|
/// LAST row of the current page as the keyset cursor — repository orders by
|
|
/// <c>(OccurredAtUtc DESC, EventId DESC)</c>, so the oldest row in the visible
|
|
/// page becomes <c>AfterOccurredAtUtc</c> + <c>AfterEventId</c> on the next
|
|
/// request. The button is disabled when the current page is short (less than
|
|
/// <see cref="PageSize"/> rows) — that's the conventional "we've reached the
|
|
/// end" signal for keyset paging without a count query.
|
|
/// </para>
|
|
///
|
|
/// <para>
|
|
/// <b>Accessibility.</b> Column resize and reorder are mouse/pointer-only —
|
|
/// they use a pointer-driven resize handle and native HTML5 drag-and-drop with
|
|
/// no keyboard equivalent and no ARIA for the reorder. This is a conscious
|
|
/// scope decision for an internal tool, not an oversight: only the column-
|
|
/// <i>customisation</i> gesture is mouse-only. The persisted layout itself
|
|
/// renders as plain HTML, so keyboard and assistive-technology users still get
|
|
/// a fully readable, navigable grid.
|
|
/// </para>
|
|
/// </summary>
|
|
public partial class AuditResultsGrid : IAsyncDisposable
|
|
{
|
|
private const int DefaultPageSize = 100;
|
|
|
|
/// <summary>Minimum persisted column width — mirrors <c>auditGrid.minWidth</c>.</summary>
|
|
private const int MinColumnWidthPx = 64;
|
|
|
|
/// <summary>sessionStorage keys (namespaced under <c>auditGrid:</c> by the JS helper).</summary>
|
|
private const string ColumnOrderStorageKey = "columnOrder";
|
|
private const string ColumnWidthsStorageKey = "columnWidths";
|
|
|
|
private readonly List<AuditEvent> _rows = new();
|
|
private int _pageNumber = 1;
|
|
private bool _loading;
|
|
private string? _error;
|
|
|
|
private AuditLogQueryFilter? _activeFilter;
|
|
|
|
[Inject] private IJSRuntime JS { get; set; } = default!;
|
|
|
|
private ElementReference _tableRef;
|
|
private DotNetObjectReference<AuditResultsGrid>? _selfRef;
|
|
|
|
// Effective column state. _columnOrder is the live display order (seeded
|
|
// from the ColumnOrder parameter / spec default, then overridden by any
|
|
// persisted sessionStorage order). _columnWidths holds per-key pixel
|
|
// widths from a prior resize; absent keys render at auto width.
|
|
private List<string>? _columnOrder;
|
|
private readonly Dictionary<string, int> _columnWidths = new();
|
|
|
|
/// <summary>
|
|
/// Filter to apply. When this parameter changes the grid resets to page 1 and
|
|
/// reissues the query — that's the contract the parent page relies on so the
|
|
/// filter-bar Apply button does not need to drive grid state manually.
|
|
/// </summary>
|
|
[Parameter] public AuditLogQueryFilter? Filter { get; set; }
|
|
|
|
/// <summary>Page size. Defaults to 100 to match the service-level default.</summary>
|
|
[Parameter] public int PageSize { get; set; } = DefaultPageSize;
|
|
|
|
/// <summary>
|
|
/// Optional column order — list of column keys in display order. When null or
|
|
/// empty the default order from Component-AuditLog.md §10 is used. The grid
|
|
/// silently drops unknown keys.
|
|
/// </summary>
|
|
[Parameter] public IReadOnlyList<string>? ColumnOrder { get; set; }
|
|
|
|
/// <summary>
|
|
/// Raised when the user clicks a row. Bundle C wires this to the drilldown
|
|
/// drawer. The event payload is the full <see cref="AuditEvent"/>.
|
|
/// </summary>
|
|
[Parameter] public EventCallback<AuditEvent> OnRowSelected { get; set; }
|
|
|
|
// Effective page size used when paging. Mirrors PageSize but bounded > 0.
|
|
private int _pageSize => Math.Max(1, PageSize);
|
|
|
|
/// <summary>
|
|
/// Default column definitions. The key is the stable identifier (used by
|
|
/// <c>data-test</c> + the column-order parameter); the label is the user-facing
|
|
/// header text. Mirrors Component-AuditLog.md §10.
|
|
/// </summary>
|
|
// Label intentionally equals Key for every column today; the separate Label
|
|
// field is future-proofing for humanised headers (e.g. "Occurred (UTC)") —
|
|
// populating it is a deliberate later change, out of scope here.
|
|
private static readonly IReadOnlyList<(string Key, string Label)> AllColumns = new[]
|
|
{
|
|
("OccurredAtUtc", "OccurredAtUtc"),
|
|
("Site", "Site"),
|
|
("Channel", "Channel"),
|
|
("Kind", "Kind"),
|
|
("Status", "Status"),
|
|
("Target", "Target"),
|
|
("Actor", "Actor"),
|
|
("ExecutionId", "ExecutionId"),
|
|
("DurationMs", "DurationMs"),
|
|
("HttpStatus", "HttpStatus"),
|
|
("ErrorMessage", "ErrorMessage"),
|
|
};
|
|
|
|
private IReadOnlyList<(string Key, string Label)> OrderedColumns()
|
|
=> ResolveOrder(_columnOrder ?? ColumnOrder);
|
|
|
|
/// <summary>
|
|
/// Resolves a candidate list of column keys into the concrete display
|
|
/// columns. Degrades gracefully so a stale persisted order is never fatal:
|
|
/// unknown keys are dropped, and any column not named in the candidate
|
|
/// list is appended in its default (spec) position. A null/empty candidate
|
|
/// yields the full default order.
|
|
/// </summary>
|
|
private static IReadOnlyList<(string Key, string Label)> ResolveOrder(IReadOnlyList<string>? candidate)
|
|
{
|
|
if (candidate is null || candidate.Count == 0)
|
|
{
|
|
return AllColumns;
|
|
}
|
|
|
|
var byKey = AllColumns.ToDictionary(c => c.Key, c => c);
|
|
var ordered = new List<(string Key, string Label)>(AllColumns.Count);
|
|
var seen = new HashSet<string>();
|
|
foreach (var key in candidate)
|
|
{
|
|
// Drop unknown keys (removed/renamed columns) and any duplicates.
|
|
if (byKey.TryGetValue(key, out var col) && seen.Add(key))
|
|
{
|
|
ordered.Add(col);
|
|
}
|
|
}
|
|
|
|
// Append any columns the candidate omitted, in default order, so a
|
|
// newly-added column still appears after a restore of an older order.
|
|
foreach (var col in AllColumns)
|
|
{
|
|
if (seen.Add(col.Key))
|
|
{
|
|
ordered.Add(col);
|
|
}
|
|
}
|
|
|
|
return ordered;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Inline style for a column's cells: emits the <c>--audit-col-width</c>
|
|
/// custom property the scoped stylesheet reads, or an empty string when
|
|
/// the column has no persisted width (auto layout).
|
|
/// </summary>
|
|
private string ColumnWidthStyle(string key)
|
|
=> _columnWidths.TryGetValue(key, out var width)
|
|
? $"--audit-col-width: {width}px;"
|
|
: string.Empty;
|
|
|
|
protected override async Task OnParametersSetAsync()
|
|
{
|
|
// Reset & reload whenever the filter reference changes. AuditLogQueryFilter
|
|
// is a record, so equality-by-value gives us a free "did the user click Apply
|
|
// with the same chips?" no-op signal. We pin to ReferenceEquals here so the
|
|
// grid reloads only when the parent hands us a new filter instance — the
|
|
// page wraps Apply in a fresh allocation, which is the canonical reload signal.
|
|
if (!ReferenceEquals(_activeFilter, Filter))
|
|
{
|
|
_activeFilter = Filter;
|
|
_pageNumber = 1;
|
|
_rows.Clear();
|
|
if (Filter is not null)
|
|
{
|
|
await LoadAsync(paging: null);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async Task NextPage()
|
|
{
|
|
if (_rows.Count == 0 || _activeFilter is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var last = _rows[^1];
|
|
var cursor = new AuditLogPaging(
|
|
PageSize: _pageSize,
|
|
AfterOccurredAtUtc: last.OccurredAtUtc,
|
|
AfterEventId: last.EventId);
|
|
|
|
await LoadAsync(cursor);
|
|
_pageNumber++;
|
|
}
|
|
|
|
private async Task LoadAsync(AuditLogPaging? paging)
|
|
{
|
|
if (_activeFilter is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_loading = true;
|
|
_error = null;
|
|
try
|
|
{
|
|
var effective = paging ?? new AuditLogPaging(_pageSize);
|
|
var page = await QueryService.QueryAsync(_activeFilter, effective);
|
|
_rows.Clear();
|
|
_rows.AddRange(page);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Surface the error in-place; the grid stays alive so the user can
|
|
// adjust the filter and retry without a page refresh.
|
|
_error = $"Query failed: {ex.Message}";
|
|
}
|
|
finally
|
|
{
|
|
_loading = false;
|
|
}
|
|
}
|
|
|
|
private async Task HandleRowClick(AuditEvent row)
|
|
{
|
|
if (OnRowSelected.HasDelegate)
|
|
{
|
|
await OnRowSelected.InvokeAsync(row);
|
|
}
|
|
}
|
|
|
|
protected override async Task OnAfterRenderAsync(bool firstRender)
|
|
{
|
|
if (firstRender)
|
|
{
|
|
// Restore any persisted order + widths first; the StateHasChanged
|
|
// inside triggers a re-render so the restored layout is on screen.
|
|
await LoadPersistedStateAsync();
|
|
_selfRef = DotNetObjectReference.Create(this);
|
|
}
|
|
|
|
// Wire (or re-wire) the JS drag handlers on every render. auditGrid.init
|
|
// is idempotent — already-bound cells are skipped, and the .NET
|
|
// reference is refreshed — so a re-render after a reorder still leaves
|
|
// every header cell wired without leaking handlers.
|
|
//
|
|
// OnColumnResized/OnColumnReordered both call StateHasChanged(), which
|
|
// re-runs this method and calls init again. That repeat call is an
|
|
// intentional cheap no-op: the @key-stable <th> nodes plus the
|
|
// __auditGridCellBound guard mean init re-scans the header and rebinds
|
|
// nothing — so there is deliberately no gating logic here.
|
|
if (_selfRef is not null)
|
|
{
|
|
try
|
|
{
|
|
await JS.InvokeVoidAsync("auditGrid.init", _tableRef, _selfRef);
|
|
}
|
|
catch (JSDisconnectedException)
|
|
{
|
|
// Circuit gone before init completed — nothing to wire.
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads the persisted column order + widths from <c>sessionStorage</c> and
|
|
/// applies them. A missing, empty, or corrupt payload is treated as "no
|
|
/// prior state" — the grid keeps its default order/widths and never throws.
|
|
/// </summary>
|
|
private async Task LoadPersistedStateAsync()
|
|
{
|
|
var orderJson = await TryLoadAsync(ColumnOrderStorageKey);
|
|
var widthsJson = await TryLoadAsync(ColumnWidthsStorageKey);
|
|
|
|
var changed = false;
|
|
|
|
if (!string.IsNullOrEmpty(orderJson))
|
|
{
|
|
try
|
|
{
|
|
var stored = JsonSerializer.Deserialize<List<string>>(orderJson);
|
|
if (stored is { Count: > 0 })
|
|
{
|
|
// Normalise through ResolveOrder so a stale key never sticks.
|
|
_columnOrder = ResolveOrder(stored).Select(c => c.Key).ToList();
|
|
changed = true;
|
|
}
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
// Corrupt payload — ignore, keep the default order.
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(widthsJson))
|
|
{
|
|
try
|
|
{
|
|
var stored = JsonSerializer.Deserialize<Dictionary<string, int>>(widthsJson);
|
|
if (stored is not null)
|
|
{
|
|
var validKeys = AllColumns.Select(c => c.Key).ToHashSet();
|
|
_columnWidths.Clear();
|
|
foreach (var (key, width) in stored)
|
|
{
|
|
// Drop widths for unknown columns; clamp to the minimum.
|
|
if (validKeys.Contains(key))
|
|
{
|
|
_columnWidths[key] = Math.Max(MinColumnWidthPx, width);
|
|
}
|
|
}
|
|
changed = _columnWidths.Count > 0 || changed;
|
|
}
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
// Corrupt payload — ignore, keep auto widths.
|
|
}
|
|
}
|
|
|
|
if (changed)
|
|
{
|
|
StateHasChanged();
|
|
}
|
|
}
|
|
|
|
private async Task<string?> TryLoadAsync(string key)
|
|
{
|
|
try
|
|
{
|
|
return await JS.InvokeAsync<string?>("auditGrid.load", key);
|
|
}
|
|
catch (JSDisconnectedException)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// JS callback: the user finished resizing a column. Persists the new
|
|
/// per-column width and re-renders so the body cells track the header.
|
|
/// </summary>
|
|
[JSInvokable]
|
|
public async Task OnColumnResized(string columnKey, int widthPx)
|
|
{
|
|
if (!AllColumns.Any(c => c.Key == columnKey))
|
|
{
|
|
return;
|
|
}
|
|
|
|
_columnWidths[columnKey] = Math.Max(MinColumnWidthPx, widthPx);
|
|
await SaveAsync(ColumnWidthsStorageKey, JsonSerializer.Serialize(_columnWidths));
|
|
StateHasChanged();
|
|
}
|
|
|
|
/// <summary>
|
|
/// JS callback: the user dropped column <paramref name="fromKey"/> onto the
|
|
/// header of <paramref name="toKey"/>. Moves the dragged column into the
|
|
/// target's slot, persists the resulting order, and re-renders.
|
|
/// </summary>
|
|
[JSInvokable]
|
|
public async Task OnColumnReordered(string fromKey, string toKey)
|
|
{
|
|
// Start from the current effective order so successive drags compose.
|
|
var order = OrderedColumns().Select(c => c.Key).ToList();
|
|
var fromIndex = order.IndexOf(fromKey);
|
|
var toIndex = order.IndexOf(toKey);
|
|
if (fromIndex < 0 || toIndex < 0 || fromIndex == toIndex)
|
|
{
|
|
return;
|
|
}
|
|
|
|
order.RemoveAt(fromIndex);
|
|
// After the removal the target index shifts left by one when the
|
|
// dragged column originally sat before it.
|
|
if (fromIndex < toIndex)
|
|
{
|
|
toIndex--;
|
|
}
|
|
order.Insert(toIndex, fromKey);
|
|
|
|
_columnOrder = order;
|
|
await SaveAsync(ColumnOrderStorageKey, JsonSerializer.Serialize(order));
|
|
StateHasChanged();
|
|
}
|
|
|
|
private async Task SaveAsync(string key, string json)
|
|
{
|
|
try
|
|
{
|
|
await JS.InvokeVoidAsync("auditGrid.save", key, json);
|
|
}
|
|
catch (JSDisconnectedException)
|
|
{
|
|
// Circuit gone — the in-memory state still drives this render.
|
|
}
|
|
}
|
|
|
|
public ValueTask DisposeAsync()
|
|
{
|
|
_selfRef?.Dispose();
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
|
|
private static string StatusBadgeClass(AuditStatus status) => status switch
|
|
{
|
|
AuditStatus.Delivered => "badge bg-success",
|
|
AuditStatus.Failed or AuditStatus.Parked or AuditStatus.Discarded => "badge bg-danger",
|
|
_ => "badge bg-secondary",
|
|
};
|
|
|
|
private static string TruncateError(string? message)
|
|
{
|
|
if (string.IsNullOrEmpty(message))
|
|
{
|
|
return "—";
|
|
}
|
|
const int max = 80;
|
|
return message.Length <= max ? message : string.Concat(message.AsSpan(0, max), "…");
|
|
}
|
|
}
|