Перепиливание под чистый DDD

backend/src/Modules/Federation/Application/Federation/Commands/HandshakeFederationCommand.cs

@@ -0,0 +1,54 @@
+
+using Knot.Modules.Stories.Domain;
+
+using Knot.Shared.Kernel;
+using Knot.Shared.Kernel.Configuration;
+using Knot.Shared.Kernel.Constants;
+using System;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Threading.Tasks;
+using MediatR;
+
+namespace Host.Application.Federation.Commands;
+
+public record HandshakeRequest(string Domain, string PublicKey);
+public record HandshakeResponse(string Domain, string PublicKey, string Status);
+
+public record HandshakeFederationCommand(HandshakeRequest Request) : ICommand<HandshakeResponse>;
+
+internal sealed class HandshakeFederationCommandHandler : ICommandHandler<HandshakeFederationCommand, HandshakeResponse>
+{
+    private readonly ISettingsService _settings;
+
+    public HandshakeFederationCommandHandler(ISettingsService settings)
+    {
+        _settings = settings;
+    }
+
+    public Task<Result<HandshakeResponse>> Handle(HandshakeFederationCommand request, CancellationToken cancellationToken)
+    {
+        var conf = _settings.Current;
+        if (!conf.EnableConfederation)
+            return Task.FromResult(Result.Failure<HandshakeResponse>(new Error(Errors.DisabledByAdmin, "Federation is disabled")));
+
+        if (string.IsNullOrEmpty(request.Request.Domain) || string.IsNullOrEmpty(request.Request.PublicKey))
+            return Task.FromResult(Result.Failure<HandshakeResponse>(DomainErrors.RequestInvalid));
+
+        var allowedList = conf.AllowedDomains?.Select(d => d.Trim().ToLower()).ToList() ?? new System.Collections.Generic.List<string>();
+        if (!allowedList.Contains(request.Request.Domain.ToLowerInvariant()))
+            return Task.FromResult(Result.Failure<HandshakeResponse>(StoryErrors.Unauthorized));
+
+        using var rsa = RSA.Create(2048);
+        var selfPublicKey = Convert.ToBase64String(rsa.ExportRSAPublicKey());
+
+        var response = new HandshakeResponse(
+            Environment.GetEnvironmentVariable("DOMAIN") ?? "knot.local",
+            selfPublicKey,
+            "Accepted"
+        );
+        
+        return Task.FromResult(Result.Success(response));
+    }
+}

backend/src/Modules/Federation/DependencyInjection.cs

@@ -0,0 +1,7 @@
+namespace Knot.Modules.Federation;
+using Microsoft.Extensions.DependencyInjection;
+public static class DependencyInjection {
+    public static IServiceCollection AddFederationModule(this IServiceCollection services) {
+        return services;
+    }
+}

backend/src/Modules/Federation/Knot.Modules.Federation.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Shared\Knot.Shared.Kernel\Knot.Shared.Kernel.csproj" />
+    <ProjectReference Include="..\..\Shared\Knot.Shared.Infrastructure\Knot.Shared.Infrastructure.csproj" />
+    <ProjectReference Include="..\Conversations\Knot.Modules.Conversations.csproj" />
+    <ProjectReference Include="..\Auth\Knot.Modules.Auth.csproj" />
+    <ProjectReference Include="..\Stories\Knot.Modules.Stories.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Carter" Version="10.0.0" />
+  </ItemGroup>
+</Project>

backend/src/Modules/Federation/Presentation/Endpoints/FederationEndpoints.cs

@@ -0,0 +1,41 @@
+using Carter;
+using MediatR;
+using Knot.Shared.Kernel.Constants;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
+using System;
+
+namespace Host.Endpoints;
+
+/// <summary>
+/// Регистрация эндпоинтов федерации.
+/// </summary>
+public sealed class FederationEndpoints : ICarterModule
+{
+    public void AddRoutes(IEndpointRouteBuilder app)
+    {
+        var group = app.MapGroup(Routes.ApiFederation);
+        
+        group.MapPost("/handshake", async ([FromBody] Host.Application.Federation.Commands.HandshakeRequest request, ISender sender, CancellationToken ct) =>
+        {
+            var result = await sender.Send(new Host.Application.Federation.Commands.HandshakeFederationCommand(request), ct);
+            if (result.IsSuccess)
+            {
+                return Results.Ok(result.Value);
+            }
+
+            if (result.Error.Code == "Unauthorized")
+            {
+                return Results.Forbid();
+            }
+            if (result.Error.Code == Knot.Shared.Kernel.Constants.Errors.DisabledByAdmin)
+            {
+                return Results.StatusCode(503);
+            }
+            
+            return Results.BadRequest(new { error = result.Error.Description });
+        });
+    }
+}