[refactor] Apply mediator DP on TrustFunction

src/ByteSync.Functions/Http/TrustFunction.cs

@@ -12,12 +12,10 @@ namespace ByteSync.Functions.Http;
 
 public class TrustFunction
 {
-    private readonly ITrustService _trustService;
     private readonly IMediator _mediator;
 
-    public TrustFunction(ITrustService trustService, IMediator mediator)
+    public TrustFunction(IMediator mediator)
     {
-        _trustService = trustService;
         _mediator = mediator;
     }
 
@@ -84,8 +82,9 @@ public async Task<HttpResponseData> SetAuthChecked(
         var client = FunctionHelper.GetClientFromContext(executionContext);
         var parameters = await FunctionHelper.DeserializeRequestBody<SetAuthCheckedParameters>(req);
 
-        await _trustService.SetAuthChecked(client, parameters);
-
+        var request = new SetAuthCheckedRequest(parameters, client);
+        await _mediator.Send(request);
+
         var response = req.CreateResponse();
         response.StatusCode = HttpStatusCode.OK;
 
@@ -101,7 +100,8 @@ public async Task<HttpResponseData> RequestTrustPublicKey(
         var client = FunctionHelper.GetClientFromContext(executionContext);
         var parameters = await FunctionHelper.DeserializeRequestBody<RequestTrustProcessParameters>(req);
 
-        await _trustService.RequestTrustPublicKey(client, parameters);
+        var request = new RequestTrustPublicKeyRequest(parameters, client);
+        await _mediator.Send(request);
 
         var response = req.CreateResponse();
         response.StatusCode = HttpStatusCode.OK;
@@ -118,7 +118,8 @@ public async Task<HttpResponseData> InformPublicKeyValidationIsFinished(
         var client = FunctionHelper.GetClientFromContext(executionContext);
         var parameters = await FunctionHelper.DeserializeRequestBody<PublicKeyValidationParameters>(req);
 
-        await _trustService.InformPublicKeyValidationIsFinished(client, parameters);
+        var request = new InformPublicKeyValidationIsFinishedRequest(parameters, client);
+        await _mediator.Send(request);
 
         var response = req.CreateResponse();
         response.StatusCode = HttpStatusCode.OK;

src/ByteSync.ServerCommon/Commands/Trusts/InformPublicKeyValidationIsFinishedCommandHandler.cs

@@ -0,0 +1,38 @@
+using ByteSync.ServerCommon.Interfaces.Repositories;
+using ByteSync.ServerCommon.Interfaces.Services.Clients;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class InformPublicKeyValidationIsFinishedCommandHandler: IRequestHandler<InformPublicKeyValidationIsFinishedRequest>
+{
+    private readonly ICloudSessionsRepository _cloudSessionsRepository;
+    private readonly IInvokeClientsService _invokeClientsService;
+    private readonly ILogger<InformPublicKeyValidationIsFinishedCommandHandler> _logger;
+
+    public InformPublicKeyValidationIsFinishedCommandHandler(ICloudSessionsRepository cloudSessionsRepository, IInvokeClientsService invokeClientService, ILogger<InformPublicKeyValidationIsFinishedCommandHandler> logger)
+    {
+        _cloudSessionsRepository = cloudSessionsRepository;
+        _invokeClientsService = invokeClientService;
+        _logger = logger;
+    }
+
+    public async Task Handle(InformPublicKeyValidationIsFinishedRequest request, CancellationToken cancellationToken)
+    {
+        var session = await _cloudSessionsRepository.Get(request.Parameters.SessionId);
+        if (session != null)
+        {
+            await _invokeClientsService.Client(request.Parameters.OtherPartyClientInstanceId).InformPublicKeyValidationIsFinished(request.Parameters).ConfigureAwait(false);
+
+            _logger.LogInformation("InformPublicKeyValidationIsFinished: {Sender} sends PublicKeyValidation to {Recipient}", request.Client.ClientInstanceId,
+                request.Parameters.OtherPartyClientInstanceId);
+        }
+        else
+        { 
+            _logger.LogInformation("InformPublicKeyValidationIsFinished: session not found for sessionId '{sessionId}'. Can not proceed",
+                request.Parameters.SessionId);
+        }
+    }
+
+}

src/ByteSync.ServerCommon/Commands/Trusts/InformPublicKeyValidationIsFinishedRequest.cs

@@ -0,0 +1,18 @@
+using ByteSync.Common.Business.Sessions.Cloud.Connections;
+using ByteSync.ServerCommon.Business.Auth;
+using MediatR;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class InformPublicKeyValidationIsFinishedRequest: IRequest
+{
+    public InformPublicKeyValidationIsFinishedRequest(PublicKeyValidationParameters parameters, Client client)
+    {
+        Parameters = parameters;
+        Client = client;
+    }
+    public PublicKeyValidationParameters Parameters { get; set; }
+
+    public Client Client { get; set; }
+
+}

src/ByteSync.ServerCommon/Commands/Trusts/RequestTrustPublicKeyCommandHandler.cs

@@ -0,0 +1,37 @@
+using ByteSync.ServerCommon.Interfaces.Repositories;
+using ByteSync.ServerCommon.Interfaces.Services.Clients;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class RequestTrustPublicKeyCommandHandler: IRequestHandler<RequestTrustPublicKeyRequest>
+{
+    private readonly ICloudSessionsRepository _cloudSessionsRepository;
+    private readonly IInvokeClientsService _invokeClientsService;
+    private readonly ILogger<SetAuthCheckedCommandHandler> _logger;
+
+    public RequestTrustPublicKeyCommandHandler(ICloudSessionsRepository cloudSessionsRepository, IInvokeClientsService invokeClientService, ILogger<SetAuthCheckedCommandHandler> logger)
+    {
+        _cloudSessionsRepository = cloudSessionsRepository;
+        _invokeClientsService = invokeClientService;
+        _logger = logger;
+    }
+
+    public async Task Handle(RequestTrustPublicKeyRequest request, CancellationToken cancellationToken)
+    {
+        var recipient = await _cloudSessionsRepository.GetSessionMember(request.Parameters.SessionId, request.Parameters.SessionMemberInstanceId);
+        if (recipient != null)
+        {
+            await _invokeClientsService.Client(recipient).RequestTrustPublicKey(request.Parameters).ConfigureAwait(false);
+
+            _logger.LogInformation("RequestTrustPublicKey: {Sender} sends trust publicKey Request to {Recipient}", request.Client.ClientInstanceId,
+                request.Parameters.SessionMemberInstanceId);
+        }
+        else
+        { 
+            _logger.LogInformation("RequestTrustPublicKey: Recipient not found. Cannot proceed");
+        }
+    }
+
+}

src/ByteSync.ServerCommon/Commands/Trusts/RequestTrustPublicKeyRequest.cs

@@ -0,0 +1,18 @@
+using ByteSync.Common.Business.Sessions.Cloud.Connections;
+using ByteSync.ServerCommon.Business.Auth;
+using MediatR;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class RequestTrustPublicKeyRequest: IRequest
+{
+    public RequestTrustPublicKeyRequest(RequestTrustProcessParameters parameters, Client client)
+    {
+        Parameters = parameters;
+        Client = client;        
+    }
+
+    public RequestTrustProcessParameters Parameters { get; set; }
+
+    public Client Client { get; set; }
+}

src/ByteSync.ServerCommon/Commands/Trusts/SetAuthCheckedCommandHandler.cs

@@ -0,0 +1,36 @@
+using ByteSync.ServerCommon.Interfaces.Repositories;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class SetAuthCheckedCommandHandler: IRequestHandler<SetAuthCheckedRequest>
+{
+    private readonly ICloudSessionsRepository _cloudSessionsRepository;
+    private readonly ILogger<SetAuthCheckedCommandHandler> _logger;
+
+    public SetAuthCheckedCommandHandler(ICloudSessionsRepository cloudSessionsRepository, ILogger<SetAuthCheckedCommandHandler> logger)
+    {
+        _cloudSessionsRepository = cloudSessionsRepository;
+        _logger = logger;
+    }
+
+    public async Task Handle(SetAuthCheckedRequest request, CancellationToken cancellationToken)
+    {
+        await _cloudSessionsRepository.Update(request.Parameters.SessionId, cloudSessionData =>
+        {
+            var member = cloudSessionData.FindMemberOrPreMember(request.Client.ClientInstanceId);
+
+            if (member == null)
+            {
+                _logger.LogInformation("{Endpoint} is neither a member nor a premember of session {session}", 
+                    request.Client.ClientInstanceId, request.Parameters.SessionId);
+                return false;
+            }
+
+            member.AuthCheckClientInstanceIds.Add(request.Parameters.CheckedClientInstanceId);
+
+            return true;
+        });
+    }
+}

src/ByteSync.ServerCommon/Commands/Trusts/SetAuthCheckedRequest.cs

@@ -0,0 +1,18 @@
+using ByteSync.Common.Business.Trust.Connections;
+using ByteSync.ServerCommon.Business.Auth;
+using MediatR;
+
+namespace ByteSync.ServerCommon.Commands.Trusts;
+
+public class SetAuthCheckedRequest: IRequest
+{
+    public SetAuthCheckedRequest(SetAuthCheckedParameters parameters, Client client)
+    {
+        Parameters = parameters;
+        Client = client;        
+    }
+
+    public SetAuthCheckedParameters Parameters { get; set; }
+
+    public Client Client { get; set; }
+}

tests/ByteSync.ServerCommon.Tests/Commands/Trusts/InformPublicKeyValidationIsFinishedCommandHandlerTests.cs

@@ -0,0 +1,73 @@
+using ByteSync.Common.Business.Sessions.Cloud.Connections;
+using ByteSync.Common.Interfaces.Hub;
+using ByteSync.ServerCommon.Business.Auth;
+using ByteSync.ServerCommon.Business.Sessions;
+using ByteSync.ServerCommon.Commands.Trusts;
+using ByteSync.ServerCommon.Interfaces.Repositories;
+using ByteSync.ServerCommon.Interfaces.Services.Clients;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace ByteSync.ServerCommon.Tests.Commands.Trusts;
+
+[TestFixture]
+public class InformPublicKeyValidationIsFinishedCommandHandlerTests
+{
+    [Test]
+    public async Task Handle_WhenSessionExists_InvokesClientInform()
+    {
+        // Arrange
+        var sessionId = "session-1";
+        var otherPartyInstanceId = "other-instance";
+
+        var repo = new Mock<ICloudSessionsRepository>();
+        repo.Setup(r => r.Get(sessionId)).ReturnsAsync(new CloudSessionData { SessionId = sessionId });
+
+        var hub = new Mock<IHubByteSyncPush>();
+        var invoke = new Mock<IInvokeClientsService>();
+        invoke.Setup(s => s.Client(otherPartyInstanceId)).Returns(hub.Object);
+
+        var logger = new Mock<ILogger<InformPublicKeyValidationIsFinishedCommandHandler>>();
+        var handler = new InformPublicKeyValidationIsFinishedCommandHandler(repo.Object, invoke.Object, logger.Object);
+
+        var parameters = new PublicKeyValidationParameters { SessionId = sessionId, OtherPartyClientInstanceId = otherPartyInstanceId };
+        var client = new Client { ClientInstanceId = "sender", ClientId = "s" };
+        var request = new InformPublicKeyValidationIsFinishedRequest(parameters, client);
+
+        // Act
+        await handler.Handle(request, default);
+
+        // Assert
+        invoke.Verify(s => s.Client(otherPartyInstanceId), Times.Once);
+        hub.Verify(h => h.InformPublicKeyValidationIsFinished(parameters), Times.Once);
+    }
+
+    [Test]
+    public async Task Handle_WhenSessionMissing_DoesNothing()
+    {
+        // Arrange
+        var sessionId = "session-1";
+        var otherPartyInstanceId = "other-instance";
+
+        var repo = new Mock<ICloudSessionsRepository>();
+        repo.Setup(r => r.Get(sessionId)).ReturnsAsync((CloudSessionData?)null);
+
+        var hub = new Mock<IHubByteSyncPush>();
+        var invoke = new Mock<IInvokeClientsService>();
+        invoke.Setup(s => s.Client(It.IsAny<string>())).Returns(hub.Object);
+
+        var logger = new Mock<ILogger<InformPublicKeyValidationIsFinishedCommandHandler>>();
+        var handler = new InformPublicKeyValidationIsFinishedCommandHandler(repo.Object, invoke.Object, logger.Object);
+
+        var parameters = new PublicKeyValidationParameters { SessionId = sessionId, OtherPartyClientInstanceId = otherPartyInstanceId };
+        var client = new Client { ClientInstanceId = "sender", ClientId = "s" };
+        var request = new InformPublicKeyValidationIsFinishedRequest(parameters, client);
+
+        // Act
+        await handler.Handle(request, default);
+
+        // Assert
+        invoke.Verify(s => s.Client(It.IsAny<string>()), Times.Never);
+        hub.Verify(h => h.InformPublicKeyValidationIsFinished(It.IsAny<PublicKeyValidationParameters>()), Times.Never);
+    }
+}