feat(m9/T26b): TemplateEdit full multi-level inherited set + read-only staleness banner

2026-06-18 13:01:38 -04:00
parent ca6e5da34b
commit 6bc2bb5430
5 changed files with 579 additions and 0 deletions
@@ -0,0 +1,35 @@
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
+
+namespace ZB.MOM.WW.ScadaBridge.CentralUI.Services;
+
+/// <summary>
+/// Read-only CentralUI facade over the template-inheritance resolve query
+/// (M9-T26b). Dispatches the <see cref="GetResolvedTemplateMembersCommand"/> to
+/// the central <c>ManagementActor</c> through the in-process
+/// <c>ManagementActorHolder</c> seam — the SAME Ask path the HTTP
+/// <c>/management</c> endpoint uses — and returns the freshly-resolved
+/// <see cref="ResolvedTemplateMembers"/> (the full transitively-inherited member
+/// set + staleness summary) so the template editor can render the effective
+/// inherited view and a base-changed banner.
+/// </summary>
+/// <remarks>
+/// This is a pure authoring-preview read: it never mutates stored rows and is
+/// not on the deploy path. A read failure (transport fault, actor not started)
+/// yields <c>null</c> (logged) so the editor degrades to its stored-row view
+/// rather than throwing. Mirrors <see cref="ISchemaLibraryService"/>'s read
+/// path / the other <c>ManagementActorHolder</c>-backed query facades.
+/// </remarks>
+public interface ITemplateInheritanceQueryService
+{
+    /// <summary>
+    /// Resolves the effective inherited member set for a template.
+    /// </summary>
+    /// <param name="templateId">The template to resolve.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>
+    /// The freshly-resolved <see cref="ResolvedTemplateMembers"/>, or <c>null</c>
+    /// when the read failed (the editor then falls back to its stored-row view).
+    /// </returns>
+    Task<ResolvedTemplateMembers?> ResolveAsync(
+        int templateId, CancellationToken cancellationToken = default);
+}
@@ -0,0 +1,133 @@
+using System.Security.Claims;
+using System.Text.Json;
+using Akka.Actor;
+using Microsoft.AspNetCore.Components.Authorization;
+using Microsoft.Extensions.Logging;
+using ZB.MOM.WW.ScadaBridge.Commons.Messages.Management;
+using ZB.MOM.WW.ScadaBridge.ManagementService;
+using ZB.MOM.WW.ScadaBridge.Security;
+
+namespace ZB.MOM.WW.ScadaBridge.CentralUI.Services;
+
+/// <summary>
+/// Default <see cref="ITemplateInheritanceQueryService"/> implementation — a thin
+/// read-only facade that dispatches the <see cref="GetResolvedTemplateMembersCommand"/>
+/// to the central <c>ManagementActor</c> through the in-process
+/// <see cref="ManagementActorHolder"/> (the same Ask seam the HTTP <c>/management</c>
+/// endpoint uses). The actor walks the full inheritance chain and returns the
+/// effective member set + staleness; none of that is re-implemented here. Mirrors
+/// <see cref="SchemaLibraryService"/>'s read path.
+/// </summary>
+public sealed class TemplateInheritanceQueryService : ITemplateInheritanceQueryService
+{
+    /// <summary>
+    /// camelCase + case-insensitive, matching <c>ManagementActor.SerializeResult</c>'s
+    /// options. <see cref="ManagementSuccess.JsonData"/> is produced with those settings,
+    /// so the deserializer must mirror them to bind every property.
+    /// </summary>
+    private static readonly JsonSerializerOptions ResultDeserializerOptions = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+    };
+
+    private static readonly TimeSpan AskTimeout = TimeSpan.FromSeconds(30);
+
+    private readonly ManagementActorHolder _holder;
+    private readonly AuthenticationStateProvider _auth;
+    private readonly ILogger<TemplateInheritanceQueryService> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TemplateInheritanceQueryService"/>.
+    /// </summary>
+    /// <param name="holder">Holder for the central <c>ManagementActor</c> reference.</param>
+    /// <param name="auth">Authentication state provider used to project the current principal.</param>
+    /// <param name="logger">Logger instance.</param>
+    public TemplateInheritanceQueryService(
+        ManagementActorHolder holder,
+        AuthenticationStateProvider auth,
+        ILogger<TemplateInheritanceQueryService> logger)
+    {
+        _holder = holder ?? throw new ArgumentNullException(nameof(holder));
+        _auth = auth ?? throw new ArgumentNullException(nameof(auth));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+    }
+
+    /// <inheritdoc/>
+    public async Task<ResolvedTemplateMembers?> ResolveAsync(
+        int templateId, CancellationToken cancellationToken = default)
+    {
+        var response = await SendAsync(new GetResolvedTemplateMembersCommand(templateId), cancellationToken);
+        if (response is ManagementSuccess success)
+        {
+            return JsonSerializer.Deserialize<ResolvedTemplateMembers>(
+                success.JsonData, ResultDeserializerOptions);
+        }
+
+        // Read path: log + return null so the editor falls back to its stored-row view.
+        _logger.LogWarning(
+            "GetResolvedTemplateMembers failed for template {TemplateId}: {Response}",
+            templateId, DescribeFailure(response));
+        return null;
+    }
+
+    /// <summary>
+    /// Wraps <paramref name="command"/> in a <see cref="ManagementEnvelope"/> for the
+    /// current principal and Asks the <c>ManagementActor</c>. Transport faults (timeout,
+    /// actor not yet started) become a synthetic <see cref="ManagementError"/> so the
+    /// caller handles one response shape.
+    /// </summary>
+    private async Task<object> SendAsync(object command, CancellationToken cancellationToken)
+    {
+        var actor = _holder.ActorRef;
+        if (actor is null)
+        {
+            return new ManagementError(
+                string.Empty, "Management service is not ready.", "SERVICE_UNAVAILABLE");
+        }
+
+        var user = await BuildAuthenticatedUserAsync();
+        var envelope = new ManagementEnvelope(user, command, Guid.NewGuid().ToString("N"));
+
+        try
+        {
+            return await actor.Ask<object>(envelope, AskTimeout, cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            // Caller-initiated cancel (e.g. circuit teardown) — propagate cleanly.
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "ManagementActor Ask failed for {Command}", command.GetType().Name);
+            return new ManagementError(string.Empty, ex.Message, "TRANSPORT_ERROR");
+        }
+    }
+
+    /// <summary>
+    /// Projects the current Blazor <see cref="ClaimsPrincipal"/> to the
+    /// <see cref="AuthenticatedUser"/> the actor authorizes against (mirrors the
+    /// claim set the HTTP endpoint constructs).
+    /// </summary>
+    private async Task<AuthenticatedUser> BuildAuthenticatedUserAsync()
+    {
+        var state = await _auth.GetAuthenticationStateAsync();
+        var principal = state.User;
+
+        var username = principal.FindFirst(JwtTokenService.UsernameClaimType)?.Value ?? "unknown";
+        var displayName = principal.FindFirst(JwtTokenService.DisplayNameClaimType)?.Value ?? username;
+        var roles = principal.FindAll(JwtTokenService.RoleClaimType).Select(c => c.Value).ToArray();
+        var permittedSiteIds = principal.FindAll(JwtTokenService.SiteIdClaimType).Select(c => c.Value).ToArray();
+
+        return new AuthenticatedUser(username, displayName, roles, permittedSiteIds);
+    }
+
+    /// <summary>Renders a fallback description for an unexpected/failure response.</summary>
+    private static string DescribeFailure(object response) => response switch
+    {
+        ManagementUnauthorized unauthorized => unauthorized.Message,
+        ManagementError error => error.Error,
+        _ => "Unexpected response from the management service.",
+    };
+}