feat(m9/T24b): move-data-connection UI dialog + action
This commit is contained in:
Joseph Doherty
@@ -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.",
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
namespace ZB.MOM.WW.ScadaBridge.CentralUI.Services;
|
||||
|
||||
/// <summary>
|
||||
/// Outcome of a single move-data-connection command dispatch. Wraps either success
|
||||
/// or a human-readable guard error, so the move dialog can render an inline result
|
||||
/// rather than reasoning about transport exceptions or the three management response
|
||||
/// shapes.
|
||||
/// </summary>
|
||||
/// <param name="Success">Whether the move succeeded.</param>
|
||||
/// <param name="Error">A human-readable error message when <paramref name="Success"/> is <c>false</c>; otherwise <c>null</c>.</param>
|
||||
public record DataConnectionMoveResult(bool Success, string? Error)
|
||||
{
|
||||
/// <summary>Creates a successful result.</summary>
|
||||
/// <returns>A successful <see cref="DataConnectionMoveResult"/>.</returns>
|
||||
public static DataConnectionMoveResult Ok() => new(true, null);
|
||||
|
||||
/// <summary>Creates a failed result carrying <paramref name="error"/>.</summary>
|
||||
/// <param name="error">The human-readable failure (typically a server guard message).</param>
|
||||
/// <returns>A failed <see cref="DataConnectionMoveResult"/>.</returns>
|
||||
public static DataConnectionMoveResult Fail(string error) => new(false, error);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// CentralUI facade over the move-data-connection management command (M9-T24b). It
|
||||
/// dispatches the strongly-typed <c>MoveDataConnectionCommand</c> 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 — so the server remains
|
||||
/// the single enforcer of the Designer role gate and every move guard (target site
|
||||
/// exists, no name collision at the target, no instance binding references it, no
|
||||
/// name-based native-alarm-source references). The UI re-implements none of that: a
|
||||
/// move is a command submitted to the server, and any guard failure comes back as a
|
||||
/// classified error.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// The current Blazor principal is projected to an <c>AuthenticatedUser</c> so the
|
||||
/// server's role gate runs against the real identity. <c>ManagementUnauthorized</c> /
|
||||
/// <c>ManagementError</c> / transport faults collapse into a typed
|
||||
/// <see cref="DataConnectionMoveResult"/> so the caller renders an inline outcome
|
||||
/// rather than throwing. Mirrors <c>ISecuredWriteService</c>.
|
||||
/// </remarks>
|
||||
public interface IDataConnectionMoveService
|
||||
{
|
||||
/// <summary>
|
||||
/// Moves the connection identified by <paramref name="connectionId"/> to
|
||||
/// <paramref name="targetSiteId"/> via the guard-running ManagementActor.
|
||||
/// </summary>
|
||||
/// <param name="connectionId">Primary key of the connection to move.</param>
|
||||
/// <param name="targetSiteId">Primary key of the destination site.</param>
|
||||
/// <param name="cancellationToken">Cancellation token.</param>
|
||||
/// <returns>A task that resolves to a <see cref="DataConnectionMoveResult"/> — success, or a classified guard / transport failure.</returns>
|
||||
Task<DataConnectionMoveResult> MoveAsync(
|
||||
int connectionId,
|
||||
int targetSiteId,
|
||||
CancellationToken cancellationToken = default);
|
||||
}
|
||||
Reference in New Issue
Block a user