feat(m9/T24b): move-data-connection UI dialog + action

2026-06-18 11:45:53 -04:00
parent dbe51e5f25
commit 16cb078cd2
7 changed files with 530 additions and 0 deletions
@@ -0,0 +1,127 @@
+using System.Security.Claims;
+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="IDataConnectionMoveService"/> implementation — a thin facade that
+/// dispatches the <see cref="MoveDataConnectionCommand"/> 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 authorizes
+/// the command against the supplied <see cref="AuthenticatedUser"/> (Designer-gated) and
+/// runs every move guard server-side — the target site must exist, the target must not
+/// already own a same-named connection, no instance binding may reference the
+/// connection, and no name-based native-alarm-source reference may be orphaned. None of
+/// that is re-implemented here; a guard failure returns as a classified error.
+/// </summary>
+/// <remarks>
+/// Mirrors <see cref="SecuredWriteService"/>: the current Blazor principal is projected
+/// to an <see cref="AuthenticatedUser"/> so the server's role gate runs against the real
+/// identity, and the three management response shapes plus any transport fault collapse
+/// into a typed <see cref="DataConnectionMoveResult"/>.
+/// </remarks>
+public sealed class DataConnectionMoveService : IDataConnectionMoveService
+{
+    private static readonly TimeSpan AskTimeout = TimeSpan.FromSeconds(30);
+
+    private readonly ManagementActorHolder _holder;
+    private readonly AuthenticationStateProvider _auth;
+    private readonly ILogger<DataConnectionMoveService> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DataConnectionMoveService"/>.
+    /// </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 DataConnectionMoveService(
+        ManagementActorHolder holder,
+        AuthenticationStateProvider auth,
+        ILogger<DataConnectionMoveService> 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<DataConnectionMoveResult> MoveAsync(
+        int connectionId, int targetSiteId, CancellationToken cancellationToken = default)
+    {
+        var response = await SendAsync(
+            new MoveDataConnectionCommand(connectionId, targetSiteId), cancellationToken);
+        return response switch
+        {
+            ManagementSuccess => DataConnectionMoveResult.Ok(),
+            ManagementUnauthorized unauthorized => DataConnectionMoveResult.Fail(unauthorized.Message),
+            ManagementError error => DataConnectionMoveResult.Fail(error.Error),
+            _ => DataConnectionMoveResult.Fail(DescribeFailure(response)),
+        };
+    }
+
+    /// <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, cancellation→propagated) become a synthetic
+    /// <see cref="ManagementError"/> so callers handle 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 — username,
+    /// display name, role claims, and the permitted-site scope claims (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.",
+    };
+}