[#20] - implements multiple clients support

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Authorization/AuthorizationHandler.cs

@@ -1,16 +1,16 @@
 namespace HttpsRichardy.Federation.Application.Handlers.Authorization;
 
-public sealed class AuthorizationHandler(IRealmCollection realmCollection, IRedirectUriPolicy redirectUriPolicy) :
+public sealed class AuthorizationHandler(IClientCollection clientCollection, IRedirectUriPolicy redirectUriPolicy) :
     IDispatchHandler<AuthorizationParameters, Result<AuthorizationScheme>>
 {
     public async Task<Result<AuthorizationScheme>> HandleAsync(
         AuthorizationParameters parameters, CancellationToken cancellation = default)
     {
-        var filters = new RealmFiltersBuilder()
-            .WithClientId(parameters.ClientId)
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.ClientId)
             .Build();
 
-        var clients = await realmCollection.GetRealmsAsync(filters, cancellation);
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation);
         var client = clients.FirstOrDefault();
 
         if (client is null)

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Authorization/ClientCredentialsGrantHandler.cs

@@ -1,30 +1,30 @@
 namespace HttpsRichardy.Federation.Application.Handlers.Authorization;
 
-public sealed class ClientCredentialsGrantHandler(IRealmCollection realmCollection, ISecurityTokenService tokenService) :
+public sealed class ClientCredentialsGrantHandler(IClientCollection clientCollection, ISecurityTokenService tokenService) :
     IAuthorizationFlowHandler
 {
     public Grant Grant => Grant.ClientCredentials;
 
     public async Task<Result<ClientAuthenticationResult>> HandleAsync(ClientAuthenticationCredentials parameters, CancellationToken cancellation = default)
     {
-        var filters = new RealmFiltersBuilder()
+        var filters = ClientFilters.WithSpecifications()
             .WithClientId(parameters.ClientId)
             .Build();
 
-        var realms = await realmCollection.GetRealmsAsync(filters, cancellation: cancellation);
-        var realm = realms.FirstOrDefault();
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation: cancellation);
+        var client = clients.FirstOrDefault();
 
-        if (realm is null)
+        if (client is null)
         {
             return Result<ClientAuthenticationResult>.Failure(AuthenticationErrors.ClientNotFound);
         }
 
-        if (parameters.ClientSecret != realm.SecretHash)
+        if (parameters.ClientSecret != client.Secret)
         {
             return Result<ClientAuthenticationResult>.Failure(AuthenticationErrors.InvalidClientCredentials);
         }
 
-        var tokenResult = await tokenService.GenerateAccessTokenAsync(realm, cancellation);
+        var tokenResult = await tokenService.GenerateAccessTokenAsync(client, cancellation);
         if (tokenResult.IsFailure)
         {
             return Result<ClientAuthenticationResult>.Failure(tokenResult.Error);

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/AssignAudienceClientHandler.cs

@@ -0,0 +1,33 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class AssignAudienceClientHandler(IClientCollection clientCollection) :
+    IDispatchHandler<AssignClientAudienceScheme, Result<IReadOnlyCollection<string>>>
+{
+    public async Task<Result<IReadOnlyCollection<string>>> HandleAsync(
+        AssignClientAudienceScheme parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation);
+        var client = clients.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result<IReadOnlyCollection<string>>.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        var audience = new Audience(parameters.Value);
+        if (client.Audiences.Any(current => current.Value == audience.Value))
+        {
+            return Result<IReadOnlyCollection<string>>.Failure(ClientErrors.ClientAlreadyHasAudience);
+        }
+
+        client.Audiences.Add(audience);
+
+        await clientCollection.UpdateAsync(client, cancellation);
+
+        return Result<IReadOnlyCollection<string>>.Success([.. client.Audiences.Select(current => current.Value)]);
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/AssignPermissionClientHandler.cs

@@ -0,0 +1,44 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class AssignPermissionClientHandler(IClientCollection clientCollection, IPermissionCollection permissionCollection) :
+    IDispatchHandler<AssignClientPermissionScheme, Result<IReadOnlyCollection<PermissionDetailsScheme>>>
+{
+    public async Task<Result<IReadOnlyCollection<PermissionDetailsScheme>>> HandleAsync(
+        AssignClientPermissionScheme parameters, CancellationToken cancellation = default)
+    {
+        var clientFilters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var permissionFilters = PermissionFilters.WithSpecifications()
+            .WithName(parameters.PermissionName.ToLower())
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(clientFilters, cancellation: cancellation);
+        var client = clients.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result<IReadOnlyCollection<PermissionDetailsScheme>>.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        var permissions = await permissionCollection.GetPermissionsAsync(permissionFilters, cancellation: cancellation);
+        var existingPermission = permissions.FirstOrDefault();
+
+        if (existingPermission is null)
+        {
+            return Result<IReadOnlyCollection<PermissionDetailsScheme>>.Failure(PermissionErrors.PermissionDoesNotExist);
+        }
+
+        if (client.Permissions.Any(permission => permission.Name == existingPermission.Name))
+        {
+            return Result<IReadOnlyCollection<PermissionDetailsScheme>>.Failure(ClientErrors.ClientAlreadyHasPermission);
+        }
+
+        client.Permissions.Add(existingPermission);
+
+        await clientCollection.UpdateAsync(client, cancellation: cancellation);
+
+        return Result<IReadOnlyCollection<PermissionDetailsScheme>>.Success(PermissionMapper.AsResponse(client.Permissions));
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/ClientCreationHandler.cs

@@ -0,0 +1,29 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class ClientCreationHandler(IClientCredentialsGenerator credentialsGenerator, IRealmProvider realmProvider, IClientCollection clientCollection) :
+    IDispatchHandler<ClientCreationScheme, Result<ClientScheme>>
+{
+    public async Task<Result<ClientScheme>> HandleAsync(ClientCreationScheme parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithName(parameters.Name)
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation: cancellation);
+        var existingClient = clients.FirstOrDefault();
+
+        if (existingClient is not null)
+        {
+            return Result<ClientScheme>.Failure(ClientErrors.ClientAlreadyExists);
+        }
+
+        var realm = realmProvider.GetCurrentRealm();
+        var credentials = await credentialsGenerator.GenerateAsync(parameters.Name, cancellation);
+
+        var client = parameters.AsClient(credentials, realm);
+
+        await clientCollection.InsertAsync(client, cancellation: cancellation);
+
+        return Result<ClientScheme>.Success(client.AsResponse());
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/ClientDeletionHandler.cs

@@ -0,0 +1,23 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class ClientDeletionHandler(IClientCollection collection) : IDispatchHandler<ClientDeletionScheme, Result>
+{
+    public async Task<Result> HandleAsync(ClientDeletionScheme parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await collection.GetClientsAsync(filters, cancellation: cancellation);
+        var client = clients.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        await collection.DeleteAsync(client, cancellation: cancellation);
+
+        return Result.Success();
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/ClientUpdateHandler.cs

@@ -0,0 +1,39 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class ClientUpdateHandler(IClientCollection collection) :
+    IDispatchHandler<ClientUpdateScheme, Result<ClientScheme>>
+{
+    public async Task<Result<ClientScheme>> HandleAsync(
+        ClientUpdateScheme parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await collection.GetClientsAsync(filters, cancellation: cancellation);
+        var client = clients.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result<ClientScheme>.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        var nameFilter = ClientFilters.WithSpecifications()
+            .WithName(parameters.Name)
+            .Build();
+
+        var clientsWithSameName = await collection.GetClientsAsync(nameFilter, cancellation: cancellation);
+        var existingClient = clientsWithSameName.FirstOrDefault(existing => existing.Id != parameters.Id);
+
+        if (existingClient is not null)
+        {
+            return Result<ClientScheme>.Failure(ClientErrors.ClientAlreadyExists);
+        }
+
+        client = ClientMapper.AsClient(parameters, client);
+
+        var updatedClient = await collection.UpdateAsync(client, cancellation: cancellation);
+
+        return Result<ClientScheme>.Success(ClientMapper.AsResponse(updatedClient));
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/FetchClientsHandler.cs

@@ -0,0 +1,29 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class FetchClientsHandler(IClientCollection clientCollection) :
+    IDispatchHandler<ClientsFetchParameters, Result<Pagination<ClientScheme>>>
+{
+    public async Task<Result<Pagination<ClientScheme>>> HandleAsync(
+        ClientsFetchParameters parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithName(parameters.Name)
+            .WithClientId(parameters.ClientId)
+            .WithSort(parameters.Sort)
+            .WithPagination(parameters.Pagination)
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation);
+        var totalClients = await clientCollection.CountClientsAsync(filters, cancellation);
+
+        var pagination = new Pagination<ClientScheme>
+        {
+            Items = [.. clients.Select(client => ClientMapper.AsResponse(client))],
+            Total = (int)totalClients,
+            PageNumber = parameters.Pagination?.PageNumber ?? 1,
+            PageSize = parameters.Pagination?.PageSize ?? 20,
+        };
+
+        return Result<Pagination<ClientScheme>>.Success(pagination);
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/ListClientAssignedPermissionsHandler.cs

@@ -0,0 +1,20 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class ListClientAssignedPermissionsHandler(IClientCollection collection) :
+    IDispatchHandler<ListClientAssignedPermissionsParameters, Result<IReadOnlyCollection<PermissionDetailsScheme>>>
+{
+    public async Task<Result<IReadOnlyCollection<PermissionDetailsScheme>>> HandleAsync(
+        ListClientAssignedPermissionsParameters parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await collection.GetClientsAsync(filters, cancellation);
+        var client = clients.FirstOrDefault();
+
+        return client is not null
+            ? Result<IReadOnlyCollection<PermissionDetailsScheme>>.Success(PermissionMapper.AsResponse(client.Permissions))
+            : Result<IReadOnlyCollection<PermissionDetailsScheme>>.Failure(ClientErrors.ClientDoesNotExist);
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/RevokeAudienceFromClientHandler.cs

@@ -0,0 +1,33 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class RevokeAudienceFromClientHandler(IClientCollection clientCollection) :
+    IDispatchHandler<RevokeClientAudienceScheme, Result<IReadOnlyCollection<string>>>
+{
+    public async Task<Result<IReadOnlyCollection<string>>> HandleAsync(
+        RevokeClientAudienceScheme parameters, CancellationToken cancellation = default)
+    {
+        var filters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(filters, cancellation);
+        var client = clients.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result<IReadOnlyCollection<string>>.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        var audienceToRemove = client.Audiences.FirstOrDefault(current => current.Value == parameters.Audience);
+        if (audienceToRemove is null)
+        {
+            return Result<IReadOnlyCollection<string>>.Failure(ClientErrors.AudienceNotAssigned);
+        }
+
+        client.Audiences.Remove(audienceToRemove);
+
+        await clientCollection.UpdateAsync(client, cancellation);
+
+        return Result<IReadOnlyCollection<string>>.Success([.. client.Audiences.Select(current => current.Value)]);
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Client/RevokeClientPermissionHandler.cs

@@ -0,0 +1,44 @@
+namespace HttpsRichardy.Federation.Application.Handlers.Client;
+
+public sealed class RevokeClientPermissionHandler(IClientCollection clientCollection, IPermissionCollection permissionCollection) :
+    IDispatchHandler<RevokeClientPermissionScheme, Result>
+{
+    public async Task<Result> HandleAsync(RevokeClientPermissionScheme parameters, CancellationToken cancellation = default)
+    {
+        var permissionFilters = PermissionFilters.WithSpecifications()
+            .WithIdentifier(parameters.PermissionId)
+            .Build();
+
+        var clientFilters = ClientFilters.WithSpecifications()
+            .WithIdentifier(parameters.Id)
+            .Build();
+
+        var clients = await clientCollection.GetClientsAsync(clientFilters, cancellation);
+        var client = clients.FirstOrDefault();
+
+        var permissions = await permissionCollection.GetPermissionsAsync(permissionFilters, cancellation);
+        var permission = permissions.FirstOrDefault();
+
+        if (client is null)
+        {
+            return Result.Failure(ClientErrors.ClientDoesNotExist);
+        }
+
+        if (permission is null)
+        {
+            return Result.Failure(PermissionErrors.PermissionDoesNotExist);
+        }
+
+        var permissionToRemove = client.Permissions.FirstOrDefault(where => where.Id == permission.Id);
+        if (permissionToRemove is null)
+        {
+            return Result.Failure(ClientErrors.PermissionNotAssigned);
+        }
+
+        client.Permissions.Remove(permissionToRemove);
+
+        await clientCollection.UpdateAsync(client, cancellation);
+
+        return Result.Success();
+    }
+}

Applications/Backend/Source/HttpsRichardy.Federation.Application/Handlers/Realm/RealmCreationHandler.cs

@@ -17,11 +17,7 @@ public async Task<Result<RealmDetailsScheme>> HandleAsync(
         }
 
         var credentials = await credentialsGenerator.GenerateAsync(parameters.Name, cancellation: cancellation);
-        var realm = RealmMapper.AsRealm(
-            realm: parameters,
-            clientId: credentials.ClientId,
-            secretHash: credentials.ClientSecret
-        );
+        var realm = RealmMapper.AsRealm(parameters);
 
         var masterFilters = RealmFilters.WithSpecifications()
             .WithName("master")