E-mail confirmation

Author: sagustavo

README.md

@@ -216,4 +216,16 @@ az containerapp create \
   --resource-group kairos \
   --environment cae-kairos \
   --yaml .github/capp-kairos-broker.yml
+```
+
+# Database Migrations
+
+Generate the migration:
+```sh
+dotnet ef migrations add MigrationName -p src/SpecificModule -s src/Gateway -o Infra/Migrations --context SpecificModuleContext
+```
+
+Apply the migrations:
+```sh
+dotnet tool run dotnet-ef database update -p src/SpecificModule -s src/Gateway --context SpecificModuleContext
 ```

src/Account/Business/UseCases/ConfirmEmailUseCase.cs

@@ -0,0 +1,71 @@
+using System;
+using Kairos.Account.Domain;
+using Kairos.Shared.Contracts;
+using Kairos.Shared.Contracts.Account;
+using MediatR;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.Extensions.Logging;
+
+namespace Kairos.Account.Business.UseCases;
+
+internal sealed class ConfirmEmailUseCase(
+    ILogger<ConfirmEmailUseCase> logger,
+    UserManager<Investor> identity
+) : IRequestHandler<ConfirmEmailCommand, Output>
+{
+    public async Task<Output> Handle(ConfirmEmailCommand input, CancellationToken cancellationToken)
+    {
+        var enrichers = new Dictionary<string, object?>
+        {
+            ["CorrelationId"] = input.CorrelationId,
+            ["AccountId"] = input.AccountId,
+        };
+
+        using (logger.BeginScope(enrichers))
+        {
+            try
+            {
+                return await ConfirmEmail(input);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "An unexpected error occurred");
+                return Output.UnexpectedError([
+                    "Algum erro inesperado ocorreu... tente novamente mais tarde.", 
+                    ex.Message]);
+            }   
+        }
+    }
+
+    async Task<Output> ConfirmEmail(ConfirmEmailCommand input)
+    {
+        if (input.AccountId is 0 || string.IsNullOrEmpty(input.ConfirmationToken))
+        {
+            return Output.InvalidInput(["A conta e seu token de confirmação devem ser especificados."]);
+        }
+
+        var account = await identity.FindByIdAsync(input.AccountId.ToString());
+
+        if (account is null)
+        {
+            logger.LogWarning("Account not found");
+            return Output.PolicyViolation([$"A conta {input.AccountId} não existe."]);
+        }
+
+        var confirmationResult = await identity.ConfirmEmailAsync(
+            account,
+            input.ConfirmationToken);
+
+        if (confirmationResult.Succeeded is false)
+        {
+            var errors = confirmationResult.Errors
+                .Select(e => e.Description)
+                .ToList();
+
+            logger.LogWarning("E-mail confirmation failed. Errors: {@Errors}", errors);
+            return Output.PolicyViolation(errors);
+        }
+
+        return Output.Ok(["E-mail confirmado com sucesso!"]);
+    }
+}

src/Account/Business/UseCases/OpenAccountUseCase.cs

@@ -63,6 +63,8 @@ public async Task<Output> Handle(
 
                 Investor investor = openAccountResult.Value!;
 
+                // TODO: usar transaction/outbox
+
                 var identityResult = await identity.CreateAsync(investor);
 
                 if (identityResult.Succeeded is false)
@@ -76,8 +78,6 @@ public async Task<Output> Handle(
 
                 var token = await identity.GenerateEmailConfirmationTokenAsync(investor);
 
-                logger.LogInformation("Account {AccountId} opened!", investor.Id);
-
                 await bus.Publish(
                     new AccountOpened(
                         investor.Id,
@@ -86,11 +86,13 @@ await bus.Publish(
                         req.Document,
                         req.Email,
                         req.Birthdate,
-                        Uri.EscapeDataString(token),
+                        token,
                         req.CorrelationId),
                     ctx => ctx.CorrelationId = req.CorrelationId,
                     cancellationToken);
 
+                logger.LogInformation("Account {AccountId} opened!", investor.Id);
+
                 return Output.Created([
                     $"Conta de investimento {investor.Id} aberta!",
                     "Confirme a abertura no e-mail que será enviado em instantes."]);

src/Account/DependencyInjection.cs

@@ -59,7 +59,7 @@ static IServiceCollection AddIdentity(
     {
         services
             .AddDbContext<AccountContext>(o => o.UseSqlServer(config["Database:Broker:ConnectionString"]!))
-            .AddIdentity<Investor, IdentityRole>(o =>
+            .AddIdentity<Investor, IdentityRole<long>>(o =>
             {
                 o.Password.RequireDigit = true;
                 o.Password.RequiredLength = 6;

src/Account/Domain/Abstraction/KairosAccount.cs

@@ -2,4 +2,4 @@
 
 namespace Kairos.Account.Domain.Abstraction;
 
-public abstract class KairosAccount : IdentityUser;
+public abstract class KairosAccount : IdentityUser<long>;

src/Account/Infra/AccountContext.cs

@@ -5,7 +5,7 @@
 
 namespace Kairos.Account.Infra;
 
-internal sealed class AccountContext : IdentityDbContext<Investor, IdentityRole, string>
+internal sealed class AccountContext : IdentityDbContext<Investor, IdentityRole<long>, long>
 {
     public AccountContext(DbContextOptions<AccountContext> options)
         : base(options)
@@ -19,11 +19,11 @@ protected override void OnModelCreating(ModelBuilder builder)
         base.OnModelCreating(builder);
 
         builder.Entity<Investor>(b => b.ToTable("Account"));
-        builder.Entity<IdentityRole>(b => b.ToTable("Role"));
-        builder.Entity<IdentityUserRole<string>>(b => b.ToTable("AccountRole"));
-        builder.Entity<IdentityUserClaim<string>>(b => b.ToTable("AccountClaim"));
-        builder.Entity<IdentityUserLogin<string>>(b => b.ToTable("AccountLogin"));
-        builder.Entity<IdentityRoleClaim<string>>(b => b.ToTable("RoleClaim"));
-        builder.Entity<IdentityUserToken<string>>(b => b.ToTable("AccountToken"));
+        builder.Entity<IdentityRole<long>>(b => b.ToTable("Role"));
+        builder.Entity<IdentityUserRole<long>>(b => b.ToTable("AccountRole"));
+        builder.Entity<IdentityUserClaim<long>>(b => b.ToTable("AccountClaim"));
+        builder.Entity<IdentityUserLogin<long>>(b => b.ToTable("AccountLogin"));
+        builder.Entity<IdentityRoleClaim<long>>(b => b.ToTable("RoleClaim"));
+        builder.Entity<IdentityUserToken<long>>(b => b.ToTable("AccountToken"));
     }
 }