Admin API for listing all tokens of an identity

Applications/AdminApi/http/Tokens/List Tokens.bru

@@ -0,0 +1,17 @@
+meta {
+  name: /Tokens
+  type: http
+  seq: 1
+}
+
+get {
+  url: {{baseUrl}}/Tokens?createdBy=did:e:localhost:dids:c179861648989f28d189c9&PageNumber=1&PageSize=1
+  body: none
+  auth: inherit
+}
+
+params:query {
+  createdBy: did:e:localhost:dids:c179861648989f28d189c9
+  PageNumber: 1
+  PageSize: 1
+}

Applications/AdminApi/src/AdminApi/AdminApi.csproj

@@ -37,6 +37,8 @@
         <ProjectReference Include="..\..\..\..\Infrastructure\Infrastructure.csproj" />
         <ProjectReference Include="..\..\..\..\Modules\Quotas\src\Quotas.Application\Quotas.Application.csproj" />
         <ProjectReference Include="..\..\..\..\Modules\Quotas\src\Quotas.Infrastructure\Quotas.Infrastructure.csproj" />
+        <ProjectReference Include="..\..\..\..\Modules\Tokens\src\Tokens.Application\Tokens.Application.csproj" />
+        <ProjectReference Include="..\..\..\..\Modules\Tokens\src\Tokens.Infrastructure\Tokens.Infrastructure.csproj" />
         <ProjectReference Include="..\AdminApi.Infrastructure.Database.Postgres\AdminApi.Infrastructure.Database.Postgres.csproj" />
         <ProjectReference Include="..\AdminApi.Infrastructure.Database.SqlServer\AdminApi.Infrastructure.Database.SqlServer.csproj" />
         <ProjectReference Include="..\AdminApi.Infrastructure\AdminApi.Infrastructure.csproj" />

Applications/AdminApi/src/AdminApi/Configuration/TokensConfiguration.cs

@@ -0,0 +1,34 @@
+using System.ComponentModel.DataAnnotations;
+using Backbone.Modules.Tokens.Application;
+
+namespace Backbone.AdminApi.Configuration;
+
+public class TokensConfiguration
+{
+    [Required]
+    public ApplicationOptions Application { get; set; } = new();
+
+    [Required]
+    public InfrastructureConfiguration Infrastructure { get; set; } = new();
+
+    public class InfrastructureConfiguration
+    {
+        [Required]
+        public SqlDatabaseConfiguration SqlDatabase { get; set; } = new();
+
+        public class SqlDatabaseConfiguration
+        {
+            [Required]
+            [MinLength(1)]
+            [RegularExpression("SqlServer|Postgres")]
+            public string Provider { get; set; } = string.Empty;
+
+            [Required]
+            [MinLength(1)]
+            public string ConnectionString { get; set; } = string.Empty;
+
+            [Required]
+            public bool EnableHealthCheck { get; set; } = true;
+        }
+    }
+}

Applications/AdminApi/src/AdminApi/Controllers/TokensController.cs

@@ -0,0 +1,38 @@
+using Backbone.BuildingBlocks.API.Mvc;
+using Backbone.BuildingBlocks.Application.Abstractions.Exceptions;
+using Backbone.BuildingBlocks.Application.Pagination;
+using Backbone.Modules.Tokens.Application;
+using Backbone.Modules.Tokens.Application.Tokens.DTOs;
+using Backbone.Modules.Tokens.Application.Tokens.Queries.ListTokensByIdentity;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using ApplicationException = Backbone.BuildingBlocks.Application.Abstractions.Exceptions.ApplicationException;
+
+namespace Backbone.AdminApi.Controllers;
+
+[Route("api/v1/[controller]")]
+[Authorize("ApiKey")]
+public class TokensController(IMediator mediator, IOptions<ApplicationOptions> options) : ApiControllerBase(mediator)
+{
+    [HttpGet]
+    [ProducesResponseType(typeof(List<TokenDTO>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> ListTokensByIdentity([FromQuery] PaginationFilter paginationFilter, [FromQuery] string createdBy, CancellationToken cancellationToken)
+    {
+        if (paginationFilter.PageSize != null)
+        {
+            var maxPageSize = options.Value.Pagination.MaxPageSize;
+
+            if (paginationFilter.PageSize > maxPageSize)
+            {
+                throw new ApplicationException(GenericApplicationErrors.Validation.InvalidPageSize(maxPageSize));
+            }
+        }
+
+        var request = new ListTokensByIdentityQuery(createdBy, paginationFilter);
+        var pagedResult = await _mediator.Send(request, cancellationToken);
+
+        return Paged(pagedResult);
+    }
+}

Applications/AdminApi/src/AdminApi/Dockerfile

@@ -76,18 +76,22 @@ COPY ["Modules/Announcements/src/Announcements.Application/Announcements.Applica
 COPY ["Modules/Announcements/src/Announcements.Domain/Announcements.Domain.csproj", "Modules/Announcements/src/Announcements.Domain/"]
 COPY ["Modules/Announcements/src/Announcements.Infrastructure/Announcements.Infrastructure.csproj", "Modules/Announcements/src/Announcements.Infrastructure/"]
 
-COPY ["Modules/Devices/src/Devices.Domain/Devices.Domain.csproj", "Modules/Devices/src/Devices.Domain/"]
-COPY ["Modules/Devices/src/Devices.Infrastructure/Devices.Infrastructure.csproj", "Modules/Devices/src/Devices.Infrastructure/"]
-COPY ["Modules/Devices/src/Devices.Application/Devices.Application.csproj", "Modules/Devices/src/Devices.Application/"]
-
 COPY ["Modules/Challenges/src/Challenges.Application/Challenges.Application.csproj", "Modules/Challenges/src/Challenges.Application/"]
 COPY ["Modules/Challenges/src/Challenges.Domain/Challenges.Domain.csproj", "Modules/Challenges/src/Challenges.Domain/"]
 COPY ["Modules/Challenges/src/Challenges.Infrastructure/Challenges.Infrastructure.csproj", "Modules/Challenges/src/Challenges.Infrastructure/"]
 
+COPY ["Modules/Devices/src/Devices.Domain/Devices.Domain.csproj", "Modules/Devices/src/Devices.Domain/"]
+COPY ["Modules/Devices/src/Devices.Infrastructure/Devices.Infrastructure.csproj", "Modules/Devices/src/Devices.Infrastructure/"]
+COPY ["Modules/Devices/src/Devices.Application/Devices.Application.csproj", "Modules/Devices/src/Devices.Application/"]
+
 COPY ["Modules/Quotas/src/Quotas.Application/Quotas.Application.csproj", "Modules/Quotas/src/Quotas.Application/"]
 COPY ["Modules/Quotas/src/Quotas.Domain/Quotas.Domain.csproj", "Modules/Quotas/src/Quotas.Domain/"]
 COPY ["Modules/Quotas/src/Quotas.Infrastructure/Quotas.Infrastructure.csproj", "Modules/Quotas/src/Quotas.Infrastructure/"]
 
+COPY ["Modules/Tokens/src/Tokens.Application/Tokens.Application.csproj", "Modules/Tokens/src/Tokens.Application/"]
+COPY ["Modules/Tokens/src/Tokens.Domain/Tokens.Domain.csproj", "Modules/Tokens/src/Tokens.Domain/"]
+COPY ["Modules/Tokens/src/Tokens.Infrastructure/Tokens.Infrastructure.csproj", "Modules/Tokens/src/Tokens.Infrastructure/"]
+
 RUN dotnet restore /p:ContinuousIntegrationBuild=true "Applications/AdminApi/src/AdminApi/AdminApi.csproj"
 
 COPY . .

Applications/AdminApi/src/AdminApi/Extensions/IServiceCollectionExtensions.cs

@@ -37,30 +37,7 @@ public static IServiceCollection AddCustomAspNetCore(this IServiceCollection ser
                 options.Filters.Add(new AutoValidateAntiforgeryTokenAttribute());
                 options.Filters.Add(new RedirectAntiforgeryValidationFailedResultFilter());
             })
-            .ConfigureApiBehaviorOptions(options =>
-            {
-                options.InvalidModelStateResponseFactory = context =>
-                {
-                    var firstPropertyWithError =
-                        context.ModelState.First(p => p.Value is { Errors.Count: > 0 });
-                    var nameOfPropertyWithError = firstPropertyWithError.Key;
-                    var firstError = firstPropertyWithError.Value!.Errors.First();
-                    var firstErrorMessage = !string.IsNullOrWhiteSpace(firstError.ErrorMessage)
-                        ? firstError.ErrorMessage
-                        : firstError.Exception != null
-                            ? firstError.Exception.Message
-                            : "";
-
-                    var formattedMessage = string.IsNullOrEmpty(nameOfPropertyWithError)
-                        ? firstErrorMessage
-                        : $"'{nameOfPropertyWithError}': {firstErrorMessage}";
-                    context.HttpContext.Response.ContentType = "application/json";
-                    var responsePayload = new HttpResponseEnvelopeError(
-                        HttpError.ForProduction(GenericApplicationErrors.Validation.InputCannotBeParsed().Code, formattedMessage,
-                            "")); // TODO: add docs
-                    return new BadRequestObjectResult(responsePayload);
-                };
-            })
+            .ConfigureApiBehaviorOptions(options => options.InvalidModelStateResponseFactory = InvalidModelStateResponseFactory())
             .AddJsonOptions(options =>
             {
                 var jsonConverters =
@@ -151,6 +128,31 @@ public static IServiceCollection AddCustomAspNetCore(this IServiceCollection ser
         return services;
     }
 
+    private static Func<ActionContext, IActionResult> InvalidModelStateResponseFactory() => context =>
+    {
+        var (nameOfPropertyWithError, value) = context.ModelState.First(p => p.Value is { Errors.Count: > 0 });
+
+        var firstError = value!.Errors.First();
+        var firstErrorMessage = !string.IsNullOrWhiteSpace(firstError.ErrorMessage)
+            ? firstError.ErrorMessage
+            : firstError.Exception != null
+                ? firstError.Exception.Message
+                : "";
+
+        var formattedMessage = string.IsNullOrEmpty(nameOfPropertyWithError)
+            ? firstErrorMessage
+            : $"'{nameOfPropertyWithError}': {firstErrorMessage}";
+
+        context.HttpContext.Response.ContentType = "application/json";
+
+        var responsePayload = new HttpResponseEnvelopeError(
+            HttpError.ForProduction(GenericApplicationErrors.Validation.InputCannotBeParsed().Code,
+                formattedMessage,
+                "")); // TODO: add docs
+
+        return new BadRequestObjectResult(responsePayload);
+    };
+
     private static object GetPropertyValue(object source, string propertyPath)
     {
         foreach (var property in propertyPath.Split('.').Select(s => source.GetType().GetProperty(s)))

Applications/AdminApi/src/AdminApi/Extensions/TokensServiceCollectionExtensions.cs

@@ -0,0 +1,26 @@
+using Backbone.AdminApi.Configuration;
+using Backbone.Modules.Tokens.Application.Extensions;
+using Backbone.Modules.Tokens.Infrastructure.Persistence;
+using Microsoft.Extensions.Options;
+
+namespace Backbone.AdminApi.Extensions;
+
+public static class TokensServiceCollectionExtensions
+{
+    public static IServiceCollection AddTokens(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddApplication(configuration.GetSection("Application"));
+
+        services.ConfigureAndValidate<TokensConfiguration.InfrastructureConfiguration>(configuration.GetSection("Infrastructure").Bind);
+
+        var infrastructureConfiguration = services.BuildServiceProvider().GetRequiredService<IOptions<TokensConfiguration.InfrastructureConfiguration>>().Value;
+
+        services.AddPersistence(options =>
+        {
+            options.DbOptions.Provider = infrastructureConfiguration.SqlDatabase.Provider;
+            options.DbOptions.DbConnectionString = infrastructureConfiguration.SqlDatabase.ConnectionString;
+        });
+
+        return services;
+    }
+}

Applications/AdminApi/src/AdminApi/Program.cs

@@ -108,6 +108,7 @@ static void ConfigureServices(IServiceCollection services, IConfiguration config
         .AddCustomIdentity(environment)
         .AddDatabase(parsedConfiguration.Infrastructure.SqlDatabase)
         .AddDevices(configuration.GetSection("Modules:Devices"))
+        .AddTokens(configuration.GetSection("Modules:Tokens"))
         .AddQuotas(parsedConfiguration.Modules.Quotas)
         .AddAnnouncements(parsedConfiguration.Modules.Announcements)
         .AddChallenges(parsedConfiguration.Modules.Challenges)

Applications/AdminApi/src/AdminApi/appsettings.json

@@ -54,6 +54,20 @@
                     "EnableHealthCheck": true
                 }
             }
+        },
+
+        "Tokens": {
+            "Application": {
+                "Pagination": {
+                    "DefaultPageSize": 50,
+                    "MaxPageSize": 200
+                }
+            },
+            "Infrastructure": {
+                "SqlDatabase": {
+                    "EnableHealthCheck": true
+                }
+            }
         }
     },
     "Logging": {
@@ -63,7 +77,6 @@
                 "Backbone": "Information",
                 "Enmeshed": "Information",
                 "AdminApi": "Information",
-
                 "Microsoft": "Information"
             }
         },
@@ -75,5 +88,7 @@
                 }
             }
         }
+
     }
+
 }

Applications/AdminApi/test/AdminApi.Tests.Integration/Features/Tokens/GET.feature

@@ -0,0 +1,10 @@
+@Integration
+Feature: GET /Tokens?createdBy={identity-address}
+
+Listing all tokens of an identity that doesn't have any tokens
+
+    Scenario: Get all Tokens for an identity with no tokens
+        Given an identity with no tokens
+        When a GET request is sent to the /Tokens endpoint with the identity's address
+        Then the response status code is 200 (OK)
+        And the response content is an empty array

Applications/AdminApi/test/AdminApi.Tests.Integration/StepDefinitions/TokensStepDefinitions.cs

@@ -0,0 +1,48 @@
+using Backbone.AdminApi.Sdk.Endpoints.Tokens.Response;
+using Backbone.AdminApi.Sdk.Services;
+using Backbone.AdminApi.Tests.Integration.Configuration;
+using Backbone.AdminApi.Tests.Integration.Extensions;
+using Backbone.BuildingBlocks.SDK.Endpoints.Common.Types;
+using Microsoft.Extensions.Options;
+using PaginationFilter = Backbone.BuildingBlocks.SDK.Endpoints.Common.Types.PaginationFilter;
+
+
+namespace Backbone.AdminApi.Tests.Integration.StepDefinitions;
+
+[Binding]
+[Scope(Feature = "GET /Tokens?createdBy={identity-address}")]
+internal class TokensStepDefinitions(HttpClientFactory factory, IOptions<HttpClientOptions> options) : BaseStepDefinitions(factory, options)
+{
+    private ApiResponse<ListTokensTestResponse> _listTokensResponse = null!;
+    private string _newIdentityAddress = string.Empty;
+
+    [Given(@"an identity with no tokens")]
+    public async Task GivenAnIdentityWithNoTokens()
+    {
+        var createIdentityResponse = await IdentityCreationHelper.CreateIdentity(_client);
+
+        createIdentityResponse.Should().BeASuccess();
+
+        _newIdentityAddress = createIdentityResponse.Result!.Address;
+    }
+
+
+    [When(@"a GET request is sent to the /Tokens endpoint with the identity's address")]
+    public async Task WhenAGETRequestIsSentToTheTokensEndpointWithTheIdentitysAddress()
+    {
+        _listTokensResponse = await _client.Tokens.ListTokensByIdentity(new PaginationFilter { PageNumber = 1, PageSize = 5 }, _newIdentityAddress, CancellationToken.None);
+    }
+
+    [Then(@"the response status code is (\d+) \(.+\)")]
+    public void ThenTheResponseStatusCodeIs(int expectedStatusCode)
+    {
+        ((int)_listTokensResponse!.Status).Should().Be(expectedStatusCode);
+    }
+
+
+    [Then(@"the response content is an empty array")]
+    public void ThenTheResponseContentIsAnEmptyArray()
+    {
+        _listTokensResponse.Result!.Count.Should().Be(0);
+    }
+}

Modules/Tokens/src/Tokens.Application/Extensions/IServiceCollectionExtensions.cs

@@ -1,20 +1,23 @@
 using Backbone.BuildingBlocks.Application.MediatR;
 using Backbone.Modules.Tokens.Application.Tokens.Commands.CreateToken;
 using FluentValidation;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Backbone.Modules.Tokens.Application.Extensions;
 
 public static class IServiceCollectionExtensions
 {
-    public static void AddApplication(this IServiceCollection services)
+    public static void AddApplication(this IServiceCollection services, IConfigurationSection applicationConfiguration)
     {
+        services.ConfigureAndValidate<ApplicationOptions>(applicationConfiguration.Bind);
+
         services.AddMediatR(c => c
-                    .RegisterServicesFromAssemblyContaining<CreateTokenCommand>()
-                    .AddOpenBehavior(typeof(LoggingBehavior<,>))
-                    .AddOpenBehavior(typeof(RequestValidationBehavior<,>))
-                    .AddOpenBehavior(typeof(QuotaEnforcerBehavior<,>))
-                );
+            .RegisterServicesFromAssemblyContaining<CreateTokenCommand>()
+            .AddOpenBehavior(typeof(LoggingBehavior<,>))
+            .AddOpenBehavior(typeof(RequestValidationBehavior<,>))
+            .AddOpenBehavior(typeof(QuotaEnforcerBehavior<,>))
+        );
         services.AddValidatorsFromAssembly(typeof(Validator).Assembly);
     }
 }

Modules/Tokens/src/Tokens.Application/Infrastructure/Persistence/Repository/ITokensRepository.cs

@@ -20,4 +20,5 @@ Task<DbPaginationResult<Token>> FindTokens(IEnumerable<ListTokensQueryItem> quer
     Task Update(IEnumerable<Token> tokens, CancellationToken cancellationToken);
     Task DeleteTokens(Expression<Func<Token, bool>> filter, CancellationToken cancellationToken);
     Task DeleteToken(Token token, CancellationToken cancellationToken);
+    Task<DbPaginationResult<Token>> FindAllTokens(PaginationFilter paginationFilter, Expression<Func<Token, bool>> filter, CancellationToken cancellationToken, bool track = false);
 }

Modules/Tokens/src/Tokens.Application/Tokens/DTOs/TokenDTO.cs

@@ -13,6 +13,7 @@ public TokenDTO(Token token)
         ExpiresAt = token.ExpiresAt;
         Content = token.Content;
         ForIdentity = token.ForIdentity?.Value;
+        IsPasswordProtected = token.Password is { Length: > 0 };
     }
 
     public string Id { get; set; }
@@ -26,4 +27,6 @@ public TokenDTO(Token token)
     public DateTime ExpiresAt { get; set; }
 
     public byte[] Content { get; set; }
+
+    public bool IsPasswordProtected { get; }
 }

Modules/Tokens/src/Tokens.Application/Tokens/Queries/ListTokens/Handler.cs

@@ -1,14 +1,15 @@
 using Backbone.BuildingBlocks.Application.Abstractions.Infrastructure.UserContext;
 using Backbone.DevelopmentKit.Identity.ValueObjects;
 using Backbone.Modules.Tokens.Application.Infrastructure.Persistence.Repository;
+using Backbone.Modules.Tokens.Application.Tokens.Queries.Shared;
 using MediatR;
 
 namespace Backbone.Modules.Tokens.Application.Tokens.Queries.ListTokens;
 
 public class Handler : IRequestHandler<ListTokensQuery, ListTokensResponse>
 {
-    private readonly ITokensRepository _tokensRepository;
     private readonly IdentityAddress _activeIdentity;
+    private readonly ITokensRepository _tokensRepository;
 
     public Handler(ITokensRepository tokensRepository, IUserContext userContext)
     {

Modules/Tokens/src/Tokens.Application/Tokens/Queries/ListTokens/ListTokensQuery.cs

@@ -1,4 +1,5 @@
 using Backbone.BuildingBlocks.Application.Pagination;
+using Backbone.Modules.Tokens.Application.Tokens.Queries.Shared;
 using MediatR;
 
 namespace Backbone.Modules.Tokens.Application.Tokens.Queries.ListTokens;