diff --git a/.config/dotnet-tools.json b/.config/dotnet-tools.json new file mode 100644 index 0000000..bb90354 --- /dev/null +++ b/.config/dotnet-tools.json @@ -0,0 +1,12 @@ +{ + "version": 1, + "isRoot": true, + "tools": { + "dotnet-ef": { + "version": "8.0.22", + "commands": [ + "dotnet-ef" + ] + } + } +} \ No newline at end of file diff --git a/.editorconfig b/.editorconfig index aa31cf1..b8439ec 100644 --- a/.editorconfig +++ b/.editorconfig @@ -538,6 +538,7 @@ dotnet_diagnostic.xUnit1051.severity = none dotnet_diagnostic.CS1998.severity = none dotnet_diagnostic.S2696.severity = none dotnet_diagnostic.CA1849.severity = none +dotnet_diagnostic.CA1305.severity = none [**/Migrations/*] generated_code = true \ No newline at end of file diff --git a/.gitignore b/.gitignore index c4937db..f301b91 100644 --- a/.gitignore +++ b/.gitignore @@ -401,4 +401,5 @@ FodyWeavers.xsd *.sln.iml .idea -.todo \ No newline at end of file +.todo +.env* \ No newline at end of file diff --git a/Directory.Packages.props b/Directory.Packages.props index a52cc85..2417274 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -17,10 +17,18 @@ - + + + + - + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + diff --git a/README.md b/README.md index e486c02..3a4fc12 100644 --- a/README.md +++ b/README.md @@ -12,9 +12,9 @@ This is a monorepo for Kairos back-end services. This repo contains (or will con More details on the underlying architecture can be seen in [this figma file](https://www.figma.com/design/kCMWPCXieoRD1e3wMS74SC/Kairos?node-id=0-1&t=hoFPXx18zhdAWdhv-1). -- Kairos Broker app: https://capp-kairos-broker.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/docs -- Kairos RabbitMQ: https://capp-kairos-rabbitmq.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/ -- Kairos Seq: https://capp-kairos-seq.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/ +- Kairos Broker app: [Link](https://capp-kairos-broker.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/docs) +- Kairos RabbitMQ: [Link](https://capp-kairos-rabbitmq.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/) +- Kairos Seq: [Link](https://capp-kairos-seq.salmonpebble-5905d3a4.eastus2.azurecontainerapps.io/) High Level Architecture @@ -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 ef database update -p src/SpecificModule -s src/Gateway --context SpecificModuleContext ``` \ No newline at end of file diff --git a/src/Account/Business/UseCases/ConfirmEmailUseCase.cs b/src/Account/Business/UseCases/ConfirmEmailUseCase.cs new file mode 100644 index 0000000..90bd27f --- /dev/null +++ b/src/Account/Business/UseCases/ConfirmEmailUseCase.cs @@ -0,0 +1,73 @@ +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 logger, + UserManager identity +) : IRequestHandler +{ + public async Task Handle(ConfirmEmailCommand input, CancellationToken cancellationToken) + { + var enrichers = new Dictionary + { + ["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 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!", + "Defina uma senha para acesso à conta."]); + } +} diff --git a/src/Account/Business/UseCases/OpenAccountUseCase.cs b/src/Account/Business/UseCases/OpenAccountUseCase.cs index 4c23143..ba52f8e 100644 --- a/src/Account/Business/UseCases/OpenAccountUseCase.cs +++ b/src/Account/Business/UseCases/OpenAccountUseCase.cs @@ -1,22 +1,30 @@ +using Kairos.Account.Domain; +using Kairos.Account.Infra; using Kairos.Shared.Contracts; using Kairos.Shared.Contracts.Account; using MassTransit; using MediatR; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Logging; namespace Kairos.Account.Business.UseCases; internal sealed class OpenAccountUseCase( ILogger logger, - IBus bus -) : IRequestHandler + IBus bus, + UserManager identity, + AccountContext db +) : IRequestHandler { - public async Task Handle(OpenAccount req, CancellationToken cancellationToken) + public async Task Handle( + OpenAccountCommand req, + CancellationToken cancellationToken) { var enrichers = new Dictionary { ["CorrelationId"] = req.CorrelationId, - ["Document"] = req.Document + ["Email"] = req.Email, }; using (logger.BeginScope(enrichers)) @@ -25,34 +33,89 @@ public async Task Handle(OpenAccount req, CancellationToken cancellation { logger.LogInformation("Starting account opening process"); - await Task.Delay(3000, cancellationToken); + Investor? existingAccount = await db.Investors + .FirstOrDefaultAsync( + i => + i.Email == req.Email || + i.PhoneNumber == req.PhoneNumber || + i.Document == req.Document, + cancellationToken); - var accountId = new Random().Next(1000, 9999999); + if (existingAccount is not null) + { + logger.LogWarning("Account identifier(s) already taken."); + return Output.PolicyViolation(["O e-mail, telefone e/ou documento já está(ão) em uso."]); + } - logger.LogInformation("Account {AccountId} created", accountId); + var openAccountResult = Investor.OpenAccount( + req.Name, + req.Document, + req.PhoneNumber, + req.Email, + req.Birthdate, + req.AcceptTerms + ); - AccountOpened @event = new( - Id: accountId, - FirstName: req.FirstName, - LastName: req.LastName, - Document: req.Document, - Email: req.Email, - Birthdate: req.Birthdate); + if (openAccountResult.IsFailure) + { + return new Output(openAccountResult); + } - await bus.Publish( - @event, - ctx => ctx.CorrelationId = req.CorrelationId, - cancellationToken); + Investor investor = openAccountResult.Value!; + + var identityResult = await identity.CreateAsync(investor); + + if (identityResult.Succeeded is false) + { + var errors = identityResult.Errors.Select(e => e.Description).ToList(); + + logger.LogWarning("Account opening failed: {@Errors}", errors); + + return Output.PolicyViolation(errors); + } + + await RaiseEvent(req, investor, cancellationToken); + + logger.LogInformation("Account {AccountId} opened!", investor.Id); return Output.Created([ - $"Conta de investimento {accountId} aberta!", + $"Conta de investimento #{investor.Id} aberta!", "Confirme a abertura no e-mail que será enviado em instantes."]); } catch (Exception ex) { logger.LogError(ex, "An unexpected error occurred"); - return Output.UnexpectedError(["Algum erro inesperado ocorreu... tente novamente mais tarde."]); + return Output.UnexpectedError([ + "Algum erro inesperado ocorreu... tente novamente mais tarde.", + ex.Message]); } } } + + async Task RaiseEvent( + OpenAccountCommand req, + Investor investor, + CancellationToken cancellationToken) + { + var emailConfirmationToken = string.Empty; + var passwordResetToken = string.Empty; + + await Task.WhenAll( + Task.Run(async () => emailConfirmationToken = await identity.GenerateEmailConfirmationTokenAsync(investor)), + Task.Run(async () => passwordResetToken = await identity.GeneratePasswordResetTokenAsync(investor))); + + await bus.Publish( + new AccountOpened( + investor.Id, + req.Name, + req.PhoneNumber, + req.Document, + req.Email, + req.Birthdate, + emailConfirmationToken, + passwordResetToken, + req.CorrelationId), + ctx => ctx.CorrelationId = req.CorrelationId, + cancellationToken); + } } \ No newline at end of file diff --git a/src/Account/Business/UseCases/SetPasswordUseCase.cs b/src/Account/Business/UseCases/SetPasswordUseCase.cs new file mode 100644 index 0000000..3437025 --- /dev/null +++ b/src/Account/Business/UseCases/SetPasswordUseCase.cs @@ -0,0 +1,64 @@ +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 SetPasswordUseCase( + UserManager identity, + ILogger logger +) : IRequestHandler +{ + public async Task Handle(SetPasswordCommand input, CancellationToken cancellationToken) + { + var enrichers = new Dictionary + { + ["AccountId"] = input.AccountId, ["CorrelationId"] = input.CorrelationId + }; + + using (logger.BeginScope(enrichers)) + { + try + { + 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."]); + } + + if (await identity.IsEmailConfirmedAsync(account) is false) + { + logger.LogWarning("Attempted to set password for an unconfirmed email"); + return Output.PolicyViolation(["O e-mail da conta precisa ser confirmado primeiro."]); + } + + var result = await identity.ResetPasswordAsync( + account, + input.Token, + input.Pass); + + if (result.Succeeded is false) + { + var errors = result.Errors.Select(e => e.Description).ToList(); + logger.LogWarning("Failed to set password. Errors: {@Errors}", errors); + return Output.PolicyViolation(errors); + } + + logger.LogInformation("Password successfully defined"); + return Output.Ok(["Senha definida com sucesso!"]); + } + catch (Exception ex) + { + logger.LogError(ex, "An unexpected error occurred"); + return Output.UnexpectedError([ + "Algum erro inesperado ocorreu... tente novamente mais tarde.", + ex.Message]); + } + } + } +} \ No newline at end of file diff --git a/src/Account/DependencyInjection.cs b/src/Account/DependencyInjection.cs index f098d3d..47a9c0e 100644 --- a/src/Account/DependencyInjection.cs +++ b/src/Account/DependencyInjection.cs @@ -1,7 +1,11 @@ using System.Reflection; +using Kairos.Account.Domain; +using Kairos.Account.Infra; using Kairos.Account.Infra.Consumers; using Kairos.Shared.Contracts.Account; using MassTransit; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Configuration; using Microsoft.Extensions.DependencyInjection; @@ -11,18 +15,25 @@ public static class DependencyInjection { public static IServiceCollection AddAccount( this IServiceCollection services, - IConfiguration config) + IConfigurationManager config) { - return services.AddMediatR(cfg => - { - cfg.LicenseKey = config["Keys:MediatR"]; - cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()); - }); + return services + .AddIdentity(config) + .AddMediatR(cfg => + { + cfg.LicenseKey = config["Keys:MediatR"]; + cfg.RegisterServicesFromAssembly(Assembly.GetExecutingAssembly()); + }); } - public static IBusRegistrationConfigurator AddAccountConsumers(this IBusRegistrationConfigurator x) + public static IBusRegistrationConfigurator ConfigureAccountBus(this IBusRegistrationConfigurator x) { x.AddConsumers(Assembly.GetExecutingAssembly()); + x.AddEntityFrameworkOutbox(c => + { + c.UseSqlServer(); + c.UseBusOutbox(); + }); return x; } @@ -46,4 +57,32 @@ public static IRabbitMqBusFactoryConfigurator ConfigureAccountEndpoints( return cfg; } + + static IServiceCollection AddIdentity( + this IServiceCollection services, + IConfigurationManager config) + { + services + .AddDbContext(o => o.UseSqlServer(config["Database:Broker:ConnectionString"]!)) + .AddIdentity>(o => + { + o.Password.RequireDigit = true; + o.Password.RequireNonAlphanumeric = false; + o.Password.RequireLowercase = false; + o.Password.RequireUppercase = false; + o.Password.RequiredLength = 6; + + o.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(5); + o.Lockout.MaxFailedAccessAttempts = 5; + o.Lockout.AllowedForNewUsers = true; + + o.SignIn.RequireConfirmedEmail = true; + o.Tokens.EmailConfirmationTokenProvider = "Default"; + o.User.RequireUniqueEmail = true; + }) + .AddEntityFrameworkStores() + .AddDefaultTokenProviders(); + + return services; + } } diff --git a/src/Account/Domain/Abstraction/KairosAccount.cs b/src/Account/Domain/Abstraction/KairosAccount.cs new file mode 100644 index 0000000..1d23951 --- /dev/null +++ b/src/Account/Domain/Abstraction/KairosAccount.cs @@ -0,0 +1,5 @@ +using Microsoft.AspNetCore.Identity; + +namespace Kairos.Account.Domain.Abstraction; + +public abstract class KairosAccount : IdentityUser; diff --git a/src/Account/Domain/Enum/Gender.cs b/src/Account/Domain/Enum/Gender.cs new file mode 100644 index 0000000..ebb7633 --- /dev/null +++ b/src/Account/Domain/Enum/Gender.cs @@ -0,0 +1,9 @@ +namespace Kairos.Account.Domain.Enum; + +public enum Gender +{ + Unspecified = 0, + Male, + Female, + Other +} diff --git a/src/Account/Domain/Enum/PersonType.cs b/src/Account/Domain/Enum/PersonType.cs new file mode 100644 index 0000000..7d98ca5 --- /dev/null +++ b/src/Account/Domain/Enum/PersonType.cs @@ -0,0 +1,14 @@ +namespace Kairos.Account.Domain.Enum; + +public enum PersonType +{ + /// + /// Individual + /// + Natural = 1, + + /// + /// Corporate + /// + Legal +} diff --git a/src/Account/Domain/Investor.cs b/src/Account/Domain/Investor.cs new file mode 100644 index 0000000..759f5fd --- /dev/null +++ b/src/Account/Domain/Investor.cs @@ -0,0 +1,80 @@ +using Kairos.Account.Domain.Abstraction; +using Kairos.Account.Domain.Enum; +using Kairos.Shared.Contracts; + +namespace Kairos.Account.Domain; + +/// +/// Investment account +/// +internal sealed class Investor : KairosAccount +{ + public string Name { get; private set; } + public string Document { get; private set; } + public DateTime Birthdate { get; private set; } + public Gender Gender { get; private set; } + public PersonType Type { get; private set; } + + Investor( + string name, + string phoneNumber, + string document, + string email, + DateTime birthdate + ) + { + Name = name; + PhoneNumber = phoneNumber; + UserName = document; + Document = document; + Email = email; + Birthdate = birthdate; + Type = document.Length == 11 ? PersonType.Natural : PersonType.Legal; + } + + public static Output OpenAccount( + string name, + string document, + string phoneNumber, + string email, + DateTime birthdate, + bool acceptTerms + ) + { + if (acceptTerms is false) + { + return Output.PolicyViolation(["Autorize a coleta de dados para prosseguir."]); + } + + if (birthdate.AddYears(18) >= DateTime.UtcNow.Date) + { + return Output.PolicyViolation(["É necessário ser maior de idade para abrir a conta."]); + } + + if (phoneNumber.Length is not 11) + { + return Output.InvalidInput(["O número de telefone deve conter DDD."]); + } + + if (document.Length is not 11 and not 14) + { + return Output.InvalidInput(["O documento deve conter apenas 11 caracteres para PF e 14 para PJ."]); + } + + var emailValidation = Shared.Contracts.Account.ValueObjects.Email.Create(email); + + if (emailValidation.IsFailure) + { + return Output.InvalidInput(emailValidation.Messages); + } + + // TODO: criar value object para phoneNumber e document + + return Output.Created(new Investor( + name, + phoneNumber, + document, + email, + birthdate)); + } +} diff --git a/src/Account/Infra/AccountContext.cs b/src/Account/Infra/AccountContext.cs new file mode 100644 index 0000000..19d7df1 --- /dev/null +++ b/src/Account/Infra/AccountContext.cs @@ -0,0 +1,35 @@ +using Kairos.Account.Domain; +using MassTransit; +using Microsoft.AspNetCore.Identity; +using Microsoft.AspNetCore.Identity.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore; + +namespace Kairos.Account.Infra; + +internal class AccountContext : IdentityDbContext, long> +{ + public AccountContext(DbContextOptions options) + : base(options) + { + } + + public virtual DbSet Investors { get; set; } = null!; + + protected override void OnModelCreating(ModelBuilder builder) + { + base.OnModelCreating(builder); + + builder.Entity(b => b.ToTable("Account")); + builder.Entity>(b => b.ToTable("Role")); + builder.Entity>(b => b.ToTable("AccountRole")); + builder.Entity>(b => b.ToTable("AccountClaim")); + builder.Entity>(b => b.ToTable("AccountLogin")); + builder.Entity>(b => b.ToTable("RoleClaim")); + builder.Entity>(b => b.ToTable("AccountToken")); + + // Outbox pattern + builder.AddInboxStateEntity(); + builder.AddOutboxMessageEntity(); + builder.AddOutboxStateEntity(); + } +} diff --git a/src/Account/Infra/Consumers/SendAccountOpenedEmailConsumer.cs b/src/Account/Infra/Consumers/SendAccountOpenedEmailConsumer.cs index 64fb0a0..83eca19 100644 --- a/src/Account/Infra/Consumers/SendAccountOpenedEmailConsumer.cs +++ b/src/Account/Infra/Consumers/SendAccountOpenedEmailConsumer.cs @@ -1,22 +1,46 @@ using Kairos.Shared.Contracts.Account; using MassTransit; +using Microsoft.Extensions.Configuration; using Microsoft.Extensions.Logging; namespace Kairos.Account.Infra.Consumers; public sealed class SendAccountOpenedEmailConsumer( - ILogger logger + ILogger logger, + IConfiguration config ) : IConsumer { public async Task Consume(ConsumeContext context) { + var message = context.Message; + using (logger.BeginScope("AccountId: {AccountId}", context.Message.Id)) { try { logger.LogInformation("Sending opened account confirmation e-mail"); - await Task.Delay(TimeSpan.FromSeconds(5)); + var baseUrl = config["KairosUI:BaseUrl"]; + + if (string.IsNullOrEmpty(baseUrl)) + { + logger.LogError("KairosUI:BaseUrl is not configured. Cannot send confirmation email."); + return; + } + + var confirmationLink = $"{baseUrl}/auth?accountId={message.Id}&token={Uri.EscapeDataString(message.EmailConfirmationToken)}"; + + var emailBody = $"

Welcome to Kairos!

" + + $"

Please confirm your account by clicking here.

"; + + logger.LogInformation( + "Sending confirmation email to {Email} with link {Link}", + message.Email, + confirmationLink); + + // await _emailService.SendAsync(message.Email, "Kairos - Confirm your account", emailBody); + + await Task.Delay(TimeSpan.FromSeconds(3)); logger.LogInformation("Opened account confirmation e-mail sent"); } diff --git a/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.Designer.cs b/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.Designer.cs new file mode 100644 index 0000000..e9a7402 --- /dev/null +++ b/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.Designer.cs @@ -0,0 +1,299 @@ +// +using System; +using Kairos.Account.Infra; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; + +#nullable disable + +namespace Kairos.Account.Infra.Migrations +{ + [DbContext(typeof(AccountContext))] + [Migration("20251205040738_CreateIdentityTables")] + partial class CreateIdentityTables + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "8.0.22") + .HasAnnotation("Relational:MaxIdentifierLength", 128); + + SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder); + + modelBuilder.Entity("Kairos.Account.Domain.Investor", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("AccessFailedCount") + .HasColumnType("int"); + + b.Property("Birthdate") + .HasColumnType("datetime2"); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Document") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("Email") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("EmailConfirmed") + .HasColumnType("bit"); + + b.Property("Gender") + .HasColumnType("int"); + + b.Property("LockoutEnabled") + .HasColumnType("bit"); + + b.Property("LockoutEnd") + .HasColumnType("datetimeoffset"); + + b.Property("Name") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("NormalizedEmail") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedUserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("PasswordHash") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumber") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumberConfirmed") + .HasColumnType("bit"); + + b.Property("SecurityStamp") + .HasColumnType("nvarchar(max)"); + + b.Property("TwoFactorEnabled") + .HasColumnType("bit"); + + b.Property("Type") + .HasColumnType("int"); + + b.Property("UserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedEmail") + .HasDatabaseName("EmailIndex"); + + b.HasIndex("NormalizedUserName") + .IsUnique() + .HasDatabaseName("UserNameIndex") + .HasFilter("[NormalizedUserName] IS NOT NULL"); + + b.ToTable("Account", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Name") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedName") + .IsUnique() + .HasDatabaseName("RoleNameIndex") + .HasFilter("[NormalizedName] IS NOT NULL"); + + b.ToTable("Role", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("RoleId"); + + b.ToTable("RoleClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("UserId"); + + b.ToTable("AccountClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderKey") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderDisplayName") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("LoginProvider", "ProviderKey"); + + b.HasIndex("UserId"); + + b.ToTable("AccountLogin", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("UserId", "RoleId"); + + b.HasIndex("RoleId"); + + b.ToTable("AccountRole", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("Name") + .HasColumnType("nvarchar(450)"); + + b.Property("Value") + .HasColumnType("nvarchar(max)"); + + b.HasKey("UserId", "LoginProvider", "Name"); + + b.ToTable("AccountToken", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.cs b/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.cs new file mode 100644 index 0000000..673d0c5 --- /dev/null +++ b/src/Account/Infra/Migrations/20251205040738_CreateIdentityTables.cs @@ -0,0 +1,231 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Kairos.Account.Infra.Migrations +{ + /// + public partial class CreateIdentityTables : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "Account", + columns: table => new + { + Id = table.Column(type: "bigint", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + Name = table.Column(type: "nvarchar(max)", nullable: false), + Document = table.Column(type: "nvarchar(max)", nullable: false), + Birthdate = table.Column(type: "datetime2", nullable: false), + Gender = table.Column(type: "int", nullable: false), + Type = table.Column(type: "int", nullable: false), + UserName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + NormalizedUserName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + Email = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + NormalizedEmail = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + EmailConfirmed = table.Column(type: "bit", nullable: false), + PasswordHash = table.Column(type: "nvarchar(max)", nullable: true), + SecurityStamp = table.Column(type: "nvarchar(max)", nullable: true), + ConcurrencyStamp = table.Column(type: "nvarchar(max)", nullable: true), + PhoneNumber = table.Column(type: "nvarchar(max)", nullable: true), + PhoneNumberConfirmed = table.Column(type: "bit", nullable: false), + TwoFactorEnabled = table.Column(type: "bit", nullable: false), + LockoutEnd = table.Column(type: "datetimeoffset", nullable: true), + LockoutEnabled = table.Column(type: "bit", nullable: false), + AccessFailedCount = table.Column(type: "int", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_Account", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "Role", + columns: table => new + { + Id = table.Column(type: "bigint", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + Name = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + NormalizedName = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + ConcurrencyStamp = table.Column(type: "nvarchar(max)", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_Role", x => x.Id); + }); + + migrationBuilder.CreateTable( + name: "AccountClaim", + columns: table => new + { + Id = table.Column(type: "int", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + UserId = table.Column(type: "bigint", nullable: false), + ClaimType = table.Column(type: "nvarchar(max)", nullable: true), + ClaimValue = table.Column(type: "nvarchar(max)", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_AccountClaim", x => x.Id); + table.ForeignKey( + name: "FK_AccountClaim_Account_UserId", + column: x => x.UserId, + principalTable: "Account", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "AccountLogin", + columns: table => new + { + LoginProvider = table.Column(type: "nvarchar(450)", nullable: false), + ProviderKey = table.Column(type: "nvarchar(450)", nullable: false), + ProviderDisplayName = table.Column(type: "nvarchar(max)", nullable: true), + UserId = table.Column(type: "bigint", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_AccountLogin", x => new { x.LoginProvider, x.ProviderKey }); + table.ForeignKey( + name: "FK_AccountLogin_Account_UserId", + column: x => x.UserId, + principalTable: "Account", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "AccountToken", + columns: table => new + { + UserId = table.Column(type: "bigint", nullable: false), + LoginProvider = table.Column(type: "nvarchar(450)", nullable: false), + Name = table.Column(type: "nvarchar(450)", nullable: false), + Value = table.Column(type: "nvarchar(max)", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_AccountToken", x => new { x.UserId, x.LoginProvider, x.Name }); + table.ForeignKey( + name: "FK_AccountToken_Account_UserId", + column: x => x.UserId, + principalTable: "Account", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "AccountRole", + columns: table => new + { + UserId = table.Column(type: "bigint", nullable: false), + RoleId = table.Column(type: "bigint", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_AccountRole", x => new { x.UserId, x.RoleId }); + table.ForeignKey( + name: "FK_AccountRole_Account_UserId", + column: x => x.UserId, + principalTable: "Account", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + table.ForeignKey( + name: "FK_AccountRole_Role_RoleId", + column: x => x.RoleId, + principalTable: "Role", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateTable( + name: "RoleClaim", + columns: table => new + { + Id = table.Column(type: "int", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + RoleId = table.Column(type: "bigint", nullable: false), + ClaimType = table.Column(type: "nvarchar(max)", nullable: true), + ClaimValue = table.Column(type: "nvarchar(max)", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_RoleClaim", x => x.Id); + table.ForeignKey( + name: "FK_RoleClaim_Role_RoleId", + column: x => x.RoleId, + principalTable: "Role", + principalColumn: "Id", + onDelete: ReferentialAction.Cascade); + }); + + migrationBuilder.CreateIndex( + name: "EmailIndex", + table: "Account", + column: "NormalizedEmail"); + + migrationBuilder.CreateIndex( + name: "UserNameIndex", + table: "Account", + column: "NormalizedUserName", + unique: true, + filter: "[NormalizedUserName] IS NOT NULL"); + + migrationBuilder.CreateIndex( + name: "IX_AccountClaim_UserId", + table: "AccountClaim", + column: "UserId"); + + migrationBuilder.CreateIndex( + name: "IX_AccountLogin_UserId", + table: "AccountLogin", + column: "UserId"); + + migrationBuilder.CreateIndex( + name: "IX_AccountRole_RoleId", + table: "AccountRole", + column: "RoleId"); + + migrationBuilder.CreateIndex( + name: "RoleNameIndex", + table: "Role", + column: "NormalizedName", + unique: true, + filter: "[NormalizedName] IS NOT NULL"); + + migrationBuilder.CreateIndex( + name: "IX_RoleClaim_RoleId", + table: "RoleClaim", + column: "RoleId"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "AccountClaim"); + + migrationBuilder.DropTable( + name: "AccountLogin"); + + migrationBuilder.DropTable( + name: "AccountRole"); + + migrationBuilder.DropTable( + name: "AccountToken"); + + migrationBuilder.DropTable( + name: "RoleClaim"); + + migrationBuilder.DropTable( + name: "Account"); + + migrationBuilder.DropTable( + name: "Role"); + } + } +} diff --git a/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.Designer.cs b/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.Designer.cs new file mode 100644 index 0000000..f18e959 --- /dev/null +++ b/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.Designer.cs @@ -0,0 +1,467 @@ +// +using System; +using Kairos.Account.Infra; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; + +#nullable disable + +namespace Kairos.Account.Infra.Migrations +{ + [DbContext(typeof(AccountContext))] + [Migration("20251205055526_CreateMassTransitOutboxTables")] + partial class CreateMassTransitOutboxTables + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "8.0.22") + .HasAnnotation("Relational:MaxIdentifierLength", 128); + + SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder); + + modelBuilder.Entity("Kairos.Account.Domain.Investor", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("AccessFailedCount") + .HasColumnType("int"); + + b.Property("Birthdate") + .HasColumnType("datetime2"); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Document") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("Email") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("EmailConfirmed") + .HasColumnType("bit"); + + b.Property("Gender") + .HasColumnType("int"); + + b.Property("LockoutEnabled") + .HasColumnType("bit"); + + b.Property("LockoutEnd") + .HasColumnType("datetimeoffset"); + + b.Property("Name") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("NormalizedEmail") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedUserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("PasswordHash") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumber") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumberConfirmed") + .HasColumnType("bit"); + + b.Property("SecurityStamp") + .HasColumnType("nvarchar(max)"); + + b.Property("TwoFactorEnabled") + .HasColumnType("bit"); + + b.Property("Type") + .HasColumnType("int"); + + b.Property("UserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedEmail") + .HasDatabaseName("EmailIndex"); + + b.HasIndex("NormalizedUserName") + .IsUnique() + .HasDatabaseName("UserNameIndex") + .HasFilter("[NormalizedUserName] IS NOT NULL"); + + b.ToTable("Account", (string)null); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.InboxState", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("Consumed") + .HasColumnType("datetime2"); + + b.Property("ConsumerId") + .HasColumnType("uniqueidentifier"); + + b.Property("Delivered") + .HasColumnType("datetime2"); + + b.Property("ExpirationTime") + .HasColumnType("datetime2"); + + b.Property("LastSequenceNumber") + .HasColumnType("bigint"); + + b.Property("LockId") + .HasColumnType("uniqueidentifier"); + + b.Property("MessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("ReceiveCount") + .HasColumnType("int"); + + b.Property("Received") + .HasColumnType("datetime2"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("rowversion"); + + b.HasKey("Id"); + + b.HasAlternateKey("MessageId", "ConsumerId"); + + b.HasIndex("Delivered"); + + b.ToTable("InboxState"); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b => + { + b.Property("SequenceNumber") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("SequenceNumber")); + + b.Property("Body") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("ContentType") + .IsRequired() + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("ConversationId") + .HasColumnType("uniqueidentifier"); + + b.Property("CorrelationId") + .HasColumnType("uniqueidentifier"); + + b.Property("DestinationAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("EnqueueTime") + .HasColumnType("datetime2"); + + b.Property("ExpirationTime") + .HasColumnType("datetime2"); + + b.Property("FaultAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("Headers") + .HasColumnType("nvarchar(max)"); + + b.Property("InboxConsumerId") + .HasColumnType("uniqueidentifier"); + + b.Property("InboxMessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("InitiatorId") + .HasColumnType("uniqueidentifier"); + + b.Property("MessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("OutboxId") + .HasColumnType("uniqueidentifier"); + + b.Property("Properties") + .HasColumnType("nvarchar(max)"); + + b.Property("RequestId") + .HasColumnType("uniqueidentifier"); + + b.Property("ResponseAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("SentTime") + .HasColumnType("datetime2"); + + b.Property("SourceAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("SequenceNumber"); + + b.HasIndex("EnqueueTime"); + + b.HasIndex("ExpirationTime"); + + b.HasIndex("OutboxId", "SequenceNumber") + .IsUnique() + .HasFilter("[OutboxId] IS NOT NULL"); + + b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber") + .IsUnique() + .HasFilter("[InboxMessageId] IS NOT NULL AND [InboxConsumerId] IS NOT NULL"); + + b.ToTable("OutboxMessage"); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b => + { + b.Property("OutboxId") + .ValueGeneratedOnAdd() + .HasColumnType("uniqueidentifier"); + + b.Property("Created") + .HasColumnType("datetime2"); + + b.Property("Delivered") + .HasColumnType("datetime2"); + + b.Property("LastSequenceNumber") + .HasColumnType("bigint"); + + b.Property("LockId") + .HasColumnType("uniqueidentifier"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("rowversion"); + + b.HasKey("OutboxId"); + + b.HasIndex("Created"); + + b.ToTable("OutboxState"); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Name") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedName") + .IsUnique() + .HasDatabaseName("RoleNameIndex") + .HasFilter("[NormalizedName] IS NOT NULL"); + + b.ToTable("Role", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("RoleId"); + + b.ToTable("RoleClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("UserId"); + + b.ToTable("AccountClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderKey") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderDisplayName") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("LoginProvider", "ProviderKey"); + + b.HasIndex("UserId"); + + b.ToTable("AccountLogin", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("UserId", "RoleId"); + + b.HasIndex("RoleId"); + + b.ToTable("AccountRole", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("Name") + .HasColumnType("nvarchar(450)"); + + b.Property("Value") + .HasColumnType("nvarchar(max)"); + + b.HasKey("UserId", "LoginProvider", "Name"); + + b.ToTable("AccountToken", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.cs b/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.cs new file mode 100644 index 0000000..35e83f3 --- /dev/null +++ b/src/Account/Infra/Migrations/20251205055526_CreateMassTransitOutboxTables.cs @@ -0,0 +1,132 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace Kairos.Account.Infra.Migrations +{ + /// + public partial class CreateMassTransitOutboxTables : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.CreateTable( + name: "InboxState", + columns: table => new + { + Id = table.Column(type: "bigint", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + MessageId = table.Column(type: "uniqueidentifier", nullable: false), + ConsumerId = table.Column(type: "uniqueidentifier", nullable: false), + LockId = table.Column(type: "uniqueidentifier", nullable: false), + RowVersion = table.Column(type: "rowversion", rowVersion: true, nullable: true), + Received = table.Column(type: "datetime2", nullable: false), + ReceiveCount = table.Column(type: "int", nullable: false), + ExpirationTime = table.Column(type: "datetime2", nullable: true), + Consumed = table.Column(type: "datetime2", nullable: true), + Delivered = table.Column(type: "datetime2", nullable: true), + LastSequenceNumber = table.Column(type: "bigint", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_InboxState", x => x.Id); + table.UniqueConstraint("AK_InboxState_MessageId_ConsumerId", x => new { x.MessageId, x.ConsumerId }); + }); + + migrationBuilder.CreateTable( + name: "OutboxMessage", + columns: table => new + { + SequenceNumber = table.Column(type: "bigint", nullable: false) + .Annotation("SqlServer:Identity", "1, 1"), + EnqueueTime = table.Column(type: "datetime2", nullable: true), + SentTime = table.Column(type: "datetime2", nullable: false), + Headers = table.Column(type: "nvarchar(max)", nullable: true), + Properties = table.Column(type: "nvarchar(max)", nullable: true), + InboxMessageId = table.Column(type: "uniqueidentifier", nullable: true), + InboxConsumerId = table.Column(type: "uniqueidentifier", nullable: true), + OutboxId = table.Column(type: "uniqueidentifier", nullable: true), + MessageId = table.Column(type: "uniqueidentifier", nullable: false), + ContentType = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: false), + Body = table.Column(type: "nvarchar(max)", nullable: false), + ConversationId = table.Column(type: "uniqueidentifier", nullable: true), + CorrelationId = table.Column(type: "uniqueidentifier", nullable: true), + InitiatorId = table.Column(type: "uniqueidentifier", nullable: true), + RequestId = table.Column(type: "uniqueidentifier", nullable: true), + SourceAddress = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + DestinationAddress = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + ResponseAddress = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + FaultAddress = table.Column(type: "nvarchar(256)", maxLength: 256, nullable: true), + ExpirationTime = table.Column(type: "datetime2", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_OutboxMessage", x => x.SequenceNumber); + }); + + migrationBuilder.CreateTable( + name: "OutboxState", + columns: table => new + { + OutboxId = table.Column(type: "uniqueidentifier", nullable: false), + LockId = table.Column(type: "uniqueidentifier", nullable: false), + RowVersion = table.Column(type: "rowversion", rowVersion: true, nullable: true), + Created = table.Column(type: "datetime2", nullable: false), + Delivered = table.Column(type: "datetime2", nullable: true), + LastSequenceNumber = table.Column(type: "bigint", nullable: true) + }, + constraints: table => + { + table.PrimaryKey("PK_OutboxState", x => x.OutboxId); + }); + + migrationBuilder.CreateIndex( + name: "IX_InboxState_Delivered", + table: "InboxState", + column: "Delivered"); + + migrationBuilder.CreateIndex( + name: "IX_OutboxMessage_EnqueueTime", + table: "OutboxMessage", + column: "EnqueueTime"); + + migrationBuilder.CreateIndex( + name: "IX_OutboxMessage_ExpirationTime", + table: "OutboxMessage", + column: "ExpirationTime"); + + migrationBuilder.CreateIndex( + name: "IX_OutboxMessage_InboxMessageId_InboxConsumerId_SequenceNumber", + table: "OutboxMessage", + columns: new[] { "InboxMessageId", "InboxConsumerId", "SequenceNumber" }, + unique: true, + filter: "[InboxMessageId] IS NOT NULL AND [InboxConsumerId] IS NOT NULL"); + + migrationBuilder.CreateIndex( + name: "IX_OutboxMessage_OutboxId_SequenceNumber", + table: "OutboxMessage", + columns: new[] { "OutboxId", "SequenceNumber" }, + unique: true, + filter: "[OutboxId] IS NOT NULL"); + + migrationBuilder.CreateIndex( + name: "IX_OutboxState_Created", + table: "OutboxState", + column: "Created"); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "InboxState"); + + migrationBuilder.DropTable( + name: "OutboxMessage"); + + migrationBuilder.DropTable( + name: "OutboxState"); + } + } +} diff --git a/src/Account/Infra/Migrations/AccountContextModelSnapshot.cs b/src/Account/Infra/Migrations/AccountContextModelSnapshot.cs new file mode 100644 index 0000000..3d3fc2e --- /dev/null +++ b/src/Account/Infra/Migrations/AccountContextModelSnapshot.cs @@ -0,0 +1,464 @@ +// +using System; +using Kairos.Account.Infra; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; + +#nullable disable + +namespace Kairos.Account.Infra.Migrations +{ + [DbContext(typeof(AccountContext))] + partial class AccountContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasAnnotation("ProductVersion", "8.0.22") + .HasAnnotation("Relational:MaxIdentifierLength", 128); + + SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder); + + modelBuilder.Entity("Kairos.Account.Domain.Investor", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("AccessFailedCount") + .HasColumnType("int"); + + b.Property("Birthdate") + .HasColumnType("datetime2"); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Document") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("Email") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("EmailConfirmed") + .HasColumnType("bit"); + + b.Property("Gender") + .HasColumnType("int"); + + b.Property("LockoutEnabled") + .HasColumnType("bit"); + + b.Property("LockoutEnd") + .HasColumnType("datetimeoffset"); + + b.Property("Name") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("NormalizedEmail") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedUserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("PasswordHash") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumber") + .HasColumnType("nvarchar(max)"); + + b.Property("PhoneNumberConfirmed") + .HasColumnType("bit"); + + b.Property("SecurityStamp") + .HasColumnType("nvarchar(max)"); + + b.Property("TwoFactorEnabled") + .HasColumnType("bit"); + + b.Property("Type") + .HasColumnType("int"); + + b.Property("UserName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedEmail") + .HasDatabaseName("EmailIndex"); + + b.HasIndex("NormalizedUserName") + .IsUnique() + .HasDatabaseName("UserNameIndex") + .HasFilter("[NormalizedUserName] IS NOT NULL"); + + b.ToTable("Account", (string)null); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.InboxState", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("Consumed") + .HasColumnType("datetime2"); + + b.Property("ConsumerId") + .HasColumnType("uniqueidentifier"); + + b.Property("Delivered") + .HasColumnType("datetime2"); + + b.Property("ExpirationTime") + .HasColumnType("datetime2"); + + b.Property("LastSequenceNumber") + .HasColumnType("bigint"); + + b.Property("LockId") + .HasColumnType("uniqueidentifier"); + + b.Property("MessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("ReceiveCount") + .HasColumnType("int"); + + b.Property("Received") + .HasColumnType("datetime2"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("rowversion"); + + b.HasKey("Id"); + + b.HasAlternateKey("MessageId", "ConsumerId"); + + b.HasIndex("Delivered"); + + b.ToTable("InboxState"); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxMessage", b => + { + b.Property("SequenceNumber") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("SequenceNumber")); + + b.Property("Body") + .IsRequired() + .HasColumnType("nvarchar(max)"); + + b.Property("ContentType") + .IsRequired() + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("ConversationId") + .HasColumnType("uniqueidentifier"); + + b.Property("CorrelationId") + .HasColumnType("uniqueidentifier"); + + b.Property("DestinationAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("EnqueueTime") + .HasColumnType("datetime2"); + + b.Property("ExpirationTime") + .HasColumnType("datetime2"); + + b.Property("FaultAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("Headers") + .HasColumnType("nvarchar(max)"); + + b.Property("InboxConsumerId") + .HasColumnType("uniqueidentifier"); + + b.Property("InboxMessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("InitiatorId") + .HasColumnType("uniqueidentifier"); + + b.Property("MessageId") + .HasColumnType("uniqueidentifier"); + + b.Property("OutboxId") + .HasColumnType("uniqueidentifier"); + + b.Property("Properties") + .HasColumnType("nvarchar(max)"); + + b.Property("RequestId") + .HasColumnType("uniqueidentifier"); + + b.Property("ResponseAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("SentTime") + .HasColumnType("datetime2"); + + b.Property("SourceAddress") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("SequenceNumber"); + + b.HasIndex("EnqueueTime"); + + b.HasIndex("ExpirationTime"); + + b.HasIndex("OutboxId", "SequenceNumber") + .IsUnique() + .HasFilter("[OutboxId] IS NOT NULL"); + + b.HasIndex("InboxMessageId", "InboxConsumerId", "SequenceNumber") + .IsUnique() + .HasFilter("[InboxMessageId] IS NOT NULL AND [InboxConsumerId] IS NOT NULL"); + + b.ToTable("OutboxMessage"); + }); + + modelBuilder.Entity("MassTransit.EntityFrameworkCoreIntegration.OutboxState", b => + { + b.Property("OutboxId") + .ValueGeneratedOnAdd() + .HasColumnType("uniqueidentifier"); + + b.Property("Created") + .HasColumnType("datetime2"); + + b.Property("Delivered") + .HasColumnType("datetime2"); + + b.Property("LastSequenceNumber") + .HasColumnType("bigint"); + + b.Property("LockId") + .HasColumnType("uniqueidentifier"); + + b.Property("RowVersion") + .IsConcurrencyToken() + .ValueGeneratedOnAddOrUpdate() + .HasColumnType("rowversion"); + + b.HasKey("OutboxId"); + + b.HasIndex("Created"); + + b.ToTable("OutboxState"); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("bigint"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ConcurrencyStamp") + .IsConcurrencyToken() + .HasColumnType("nvarchar(max)"); + + b.Property("Name") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.Property("NormalizedName") + .HasMaxLength(256) + .HasColumnType("nvarchar(256)"); + + b.HasKey("Id"); + + b.HasIndex("NormalizedName") + .IsUnique() + .HasDatabaseName("RoleNameIndex") + .HasFilter("[NormalizedName] IS NOT NULL"); + + b.ToTable("Role", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("RoleId"); + + b.ToTable("RoleClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.Property("Id") + .ValueGeneratedOnAdd() + .HasColumnType("int"); + + SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property("Id")); + + b.Property("ClaimType") + .HasColumnType("nvarchar(max)"); + + b.Property("ClaimValue") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("Id"); + + b.HasIndex("UserId"); + + b.ToTable("AccountClaim", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderKey") + .HasColumnType("nvarchar(450)"); + + b.Property("ProviderDisplayName") + .HasColumnType("nvarchar(max)"); + + b.Property("UserId") + .HasColumnType("bigint"); + + b.HasKey("LoginProvider", "ProviderKey"); + + b.HasIndex("UserId"); + + b.ToTable("AccountLogin", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("RoleId") + .HasColumnType("bigint"); + + b.HasKey("UserId", "RoleId"); + + b.HasIndex("RoleId"); + + b.ToTable("AccountRole", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.Property("UserId") + .HasColumnType("bigint"); + + b.Property("LoginProvider") + .HasColumnType("nvarchar(450)"); + + b.Property("Name") + .HasColumnType("nvarchar(450)"); + + b.Property("Value") + .HasColumnType("nvarchar(max)"); + + b.HasKey("UserId", "LoginProvider", "Name"); + + b.ToTable("AccountToken", (string)null); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b => + { + b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null) + .WithMany() + .HasForeignKey("RoleId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); + + modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b => + { + b.HasOne("Kairos.Account.Domain.Investor", null) + .WithMany() + .HasForeignKey("UserId") + .OnDelete(DeleteBehavior.Cascade) + .IsRequired(); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Account/Kairos.Account.csproj b/src/Account/Kairos.Account.csproj index 4ac9bf6..d2ba90f 100644 --- a/src/Account/Kairos.Account.csproj +++ b/src/Account/Kairos.Account.csproj @@ -9,4 +9,8 @@ + + + + \ No newline at end of file diff --git a/src/Gateway/DependencyInjection.cs b/src/Gateway/DependencyInjection.cs index 27632f1..ac6050e 100644 --- a/src/Gateway/DependencyInjection.cs +++ b/src/Gateway/DependencyInjection.cs @@ -1,7 +1,6 @@ using System.Text.Json.Serialization; using Carter; using Kairos.Account; -using Kairos.Gateway.Filters; using Kairos.Shared.Configuration; using Kairos.Shared.Contracts; using Mapster; @@ -55,11 +54,13 @@ static IServiceCollection AddEventBus(this IServiceCollection services, IConfigu return services.AddMassTransit(bus => { + bus.SetKebabCaseEndpointNameFormatter(); + bus - .AddAccountConsumers() + .ConfigureAccountBus() .ConfigureHealthCheckOptions(o => o.Name = "rabbitmq") .AddConfigureEndpointsCallback((name, cfg) => cfg.UseMessageRetry(r => r.Interval(3, TimeSpan.FromSeconds(5)))); - + bus.UsingRabbitMq((ctx, cfg) => { EventBusOptions options = ctx.GetRequiredService>().Value; diff --git a/src/Gateway/Filters/ResponseFormatter.cs b/src/Gateway/Filters/ResponseFormatter.cs index 264d895..76624ad 100644 --- a/src/Gateway/Filters/ResponseFormatter.cs +++ b/src/Gateway/Filters/ResponseFormatter.cs @@ -28,7 +28,7 @@ internal sealed class ResponseFormatter(ILogger logger) : IEn OutputStatus.Empty => StatusCodes.Status204NoContent, OutputStatus.InvalidInput => StatusCodes.Status400BadRequest, OutputStatus.NotFound => StatusCodes.Status404NotFound, - OutputStatus.BusinessLogicViolation => StatusCodes.Status422UnprocessableEntity, + OutputStatus.PolicyViolation => StatusCodes.Status422UnprocessableEntity, _ => StatusCodes.Status500InternalServerError, }; diff --git a/src/Gateway/Kairos.Gateway.csproj b/src/Gateway/Kairos.Gateway.csproj index b150373..c05b316 100644 --- a/src/Gateway/Kairos.Gateway.csproj +++ b/src/Gateway/Kairos.Gateway.csproj @@ -19,7 +19,6 @@ - \ No newline at end of file diff --git a/src/Gateway/Modules/Account/AccountModule.cs b/src/Gateway/Modules/Account/AccountModule.cs new file mode 100644 index 0000000..874359d --- /dev/null +++ b/src/Gateway/Modules/Account/AccountModule.cs @@ -0,0 +1,83 @@ +using Carter; +using Kairos.Gateway.Modules.Account.Request; +using Kairos.Shared.Contracts.Account; +using MediatR; +using Microsoft.AspNetCore.Mvc; +using Response = Kairos.Gateway.Filters.Response; + +namespace Kairos.Gateway.Modules; + +public sealed class AccountModule : CarterModule +{ + readonly IMediator _mediator; + + public AccountModule(IMediator mediator) : base("/api/v1/account") + { + WithTags("Account"); + + _mediator = mediator; + } + + public override void AddRoutes(IEndpointRouteBuilder app) + { + app.MapPost("/open", + ([FromBody] OpenAccountCommand command) => + _mediator.Send(command)) + .WithSummary("Open an investment account") + .Produces(StatusCodes.Status201Created) + .Produces(StatusCodes.Status422UnprocessableEntity) + .Produces(StatusCodes.Status400BadRequest) + .Produces(StatusCodes.Status500InternalServerError) + .WithOpenApi(e => + { + e.Responses["201"].Description = "The account was opened successfully and is pending email confirmation."; + e.Responses["422"].Description = "Policy violation, such as the user being underage or not accepting the terms."; + e.Responses["400"].Description = "Invalid input, such as a malformed e-mail or document number."; + e.Responses["500"].Description = "An unexpected server error occurred."; + return e; + }); + + app.MapPatch("/{id}/confirm-email", + ([FromRoute] long id, [FromBody] ConfirmEmailRequest req) => + _mediator.Send(new ConfirmEmailCommand( + id, + req.ConfirmationToken, + Guid.NewGuid()))) + .WithSummary("Account opening e-mail confirmation") + .Produces(StatusCodes.Status200OK) + .Produces(StatusCodes.Status422UnprocessableEntity) + .Produces(StatusCodes.Status400BadRequest) + .Produces(StatusCodes.Status500InternalServerError) + .WithOpenApi(e => + { + e.Responses["200"].Description = "E-mail successfully confirmed."; + e.Responses["422"].Description = "Policy violation, e.g., expired token or the account does not exist."; + e.Responses["400"].Description = "Invalid input, such as an invalid account number"; + e.Responses["500"].Description = "An unexpected server error occurred."; + return e; + }); + + app.MapPatch("/{id}/set-password", + ([FromRoute] long id, [FromBody] SetPasswordRequest req) => + _mediator.Send(new SetPasswordCommand( + id, + req.Pass, + req.PassConfirmation, + req.Token, + Guid.NewGuid()))) + .WithSummary("Defines or resets an account's password") + .WithDescription("A valid password reset token, which comes from e-mail, must be provided.") + .Produces(StatusCodes.Status200OK) + .Produces(StatusCodes.Status422UnprocessableEntity) + .Produces(StatusCodes.Status400BadRequest) + .Produces(StatusCodes.Status500InternalServerError) + .WithOpenApi(e => + { + e.Responses["200"].Description = "Password successfully (re)defined."; + e.Responses["422"].Description = "Policy violation, e.g., the e-mail is not confirmed."; + e.Responses["400"].Description = "Invalid input, such as missing the pass confirmation."; + e.Responses["500"].Description = "An unexpected server error occurred."; + return e; + }); + } +} \ No newline at end of file diff --git a/src/Gateway/Modules/Account/Request/ConfirmEmailRequest.cs b/src/Gateway/Modules/Account/Request/ConfirmEmailRequest.cs new file mode 100644 index 0000000..33895a6 --- /dev/null +++ b/src/Gateway/Modules/Account/Request/ConfirmEmailRequest.cs @@ -0,0 +1,3 @@ +namespace Kairos.Gateway.Modules.Account.Request; + +internal sealed record ConfirmEmailRequest(string ConfirmationToken); diff --git a/src/Gateway/Modules/Account/Request/SetPasswordRequest.cs b/src/Gateway/Modules/Account/Request/SetPasswordRequest.cs new file mode 100644 index 0000000..39f5125 --- /dev/null +++ b/src/Gateway/Modules/Account/Request/SetPasswordRequest.cs @@ -0,0 +1,13 @@ +using System.ComponentModel.DataAnnotations; + +namespace Kairos.Gateway.Modules.Account.Request; + +internal sealed record SetPasswordRequest( + [Required] + string Pass, + + [Required] + string PassConfirmation, + + [Required] + string Token); diff --git a/src/Gateway/Modules/AccountModule.cs b/src/Gateway/Modules/AccountModule.cs deleted file mode 100644 index d1fa2d0..0000000 --- a/src/Gateway/Modules/AccountModule.cs +++ /dev/null @@ -1,28 +0,0 @@ -using Carter; -using Kairos.Shared.Contracts; -using Kairos.Shared.Contracts.Account; -using MediatR; -using Microsoft.AspNetCore.Mvc; - -namespace Kairos.Gateway.Modules; - -public sealed class AccountModule : CarterModule -{ - readonly IMediator _mediator; - - public AccountModule(IMediator mediator) : base("/api/v1/account") - { - WithTags("Account"); - - _mediator = mediator; - } - - public override void AddRoutes(IEndpointRouteBuilder app) - { - app - .MapPost( - "/open", - ([FromBody] OpenAccount command) => _mediator.Send(command)) - .WithDescription("Open an investment account"); - } -} \ No newline at end of file diff --git a/src/Shared/Abstractions/Domain/ValueObject.cs b/src/Shared/Abstractions/Domain/ValueObject.cs new file mode 100644 index 0000000..2b9e639 --- /dev/null +++ b/src/Shared/Abstractions/Domain/ValueObject.cs @@ -0,0 +1,52 @@ +namespace Kairos.Shared.Abstractions.Domain; + +// referência: https://github.com/vkhorikov/CSharpFunctionalExtensions/blob/master/CSharpFunctionalExtensions/ValueObject/ValueObject.cs + +/// +/// Marker interface for Value Objects; It comes in handy for simple +/// values that don't need to implement the complex +/// +public interface IValueObject; + +/// +/// Abstracts complex value objects (more than 1 prop) comparisons +/// +public abstract class ValueObject : IEquatable, IValueObject +{ + int? _cachedHashCode; + + public abstract IEnumerable GetEqualityComponents(); + + public bool Equals(ValueObject? other) => Equals((object?)other); + + public override bool Equals(object? obj) + { + if (obj is null || obj.GetType() != GetType()) return false; + + var otherValueObject = (ValueObject)obj; + + return GetEqualityComponents() + .SequenceEqual(otherValueObject.GetEqualityComponents()); + } + + public static bool operator ==(ValueObject left, ValueObject right) + { + if (left is null && right is null) return true; + + return Equals(left, right); + } + + public static bool operator !=(ValueObject left, ValueObject right) => + !(left == right); + + public override int GetHashCode() + { + if (!_cachedHashCode.HasValue) + _cachedHashCode = GetEqualityComponents() + .Aggregate(1, (total, value) => + unchecked(total * 23 + (value?.GetHashCode() ?? 0)) + ); + + return _cachedHashCode.Value; + } +} diff --git a/src/Shared/Contracts/Account/AccountOpened.cs b/src/Shared/Contracts/Account/AccountOpened.cs deleted file mode 100644 index 46be0f6..0000000 --- a/src/Shared/Contracts/Account/AccountOpened.cs +++ /dev/null @@ -1,9 +0,0 @@ -namespace Kairos.Shared.Contracts.Account; - -public sealed record AccountOpened( - int Id, - string FirstName, - string LastName, - string Document, - string Email, - DateTime Birthdate); \ No newline at end of file diff --git a/src/Shared/Contracts/Account/ConfirmEmailCommand.cs b/src/Shared/Contracts/Account/ConfirmEmailCommand.cs new file mode 100644 index 0000000..bd4c498 --- /dev/null +++ b/src/Shared/Contracts/Account/ConfirmEmailCommand.cs @@ -0,0 +1,9 @@ +using System; +using Kairos.Shared.Abstractions; + +namespace Kairos.Shared.Contracts.Account; + +public sealed record ConfirmEmailCommand( + long AccountId, + string ConfirmationToken, + Guid CorrelationId) : ICommand; diff --git a/src/Shared/Contracts/Account/OpenAccount/AccountOpened.cs b/src/Shared/Contracts/Account/OpenAccount/AccountOpened.cs new file mode 100644 index 0000000..27c7ced --- /dev/null +++ b/src/Shared/Contracts/Account/OpenAccount/AccountOpened.cs @@ -0,0 +1,12 @@ +namespace Kairos.Shared.Contracts.Account; + +public sealed record AccountOpened( + long Id, + string Name, + string PhoneNumber, + string Document, + string Email, + DateTime Birthdate, + string EmailConfirmationToken, + string PasswordResetToken, + Guid CorrelationId); \ No newline at end of file diff --git a/src/Shared/Contracts/Account/OpenAccount.cs b/src/Shared/Contracts/Account/OpenAccount/OpenAccountCommand.cs similarity index 68% rename from src/Shared/Contracts/Account/OpenAccount.cs rename to src/Shared/Contracts/Account/OpenAccount/OpenAccountCommand.cs index a554acf..deb1c83 100644 --- a/src/Shared/Contracts/Account/OpenAccount.cs +++ b/src/Shared/Contracts/Account/OpenAccount/OpenAccountCommand.cs @@ -2,9 +2,9 @@ namespace Kairos.Shared.Contracts.Account; -public sealed record OpenAccount( - string FirstName, - string LastName, +public sealed record OpenAccountCommand( + string Name, + string PhoneNumber, string Document, string Email, DateTime Birthdate, diff --git a/src/Shared/Contracts/Account/SetPasswordCommand.cs b/src/Shared/Contracts/Account/SetPasswordCommand.cs new file mode 100644 index 0000000..b0608a4 --- /dev/null +++ b/src/Shared/Contracts/Account/SetPasswordCommand.cs @@ -0,0 +1,10 @@ +using Kairos.Shared.Abstractions; + +namespace Kairos.Shared.Contracts.Account; + +public sealed record SetPasswordCommand( + long AccountId, + string Pass, + string PassConfirmation, + string Token, + Guid CorrelationId) : ICommand; \ No newline at end of file diff --git a/src/Shared/Contracts/Account/ValueObjects/Email.cs b/src/Shared/Contracts/Account/ValueObjects/Email.cs new file mode 100644 index 0000000..177e4d7 --- /dev/null +++ b/src/Shared/Contracts/Account/ValueObjects/Email.cs @@ -0,0 +1,37 @@ +using System.Text.RegularExpressions; +using Kairos.Shared.Abstractions.Domain; + +namespace Kairos.Shared.Contracts.Account.ValueObjects; + +public sealed record Email : IValueObject +{ + const string Pattern = @"^.+@.+\..+$"; + const byte MaxLength = 100; + const byte MinLength = 4; + + public string Value { get; init; } + + public static implicit operator Email?(string value) => + Create(value)?.Value; + + Email(string value) => Value = value; + + public static Output Create(string value) + { + string error = value switch + { + var v when string.IsNullOrEmpty(v) => "Email não preenchido", + var v when v.Length < MinLength => $"Email deve ter ao menos {MinLength} caracteres", + var v when v.Length > MaxLength => $"Email não pode ultrapassar {MaxLength} caracteres", + var v when !Regex.IsMatch(v, Pattern) => "Email deve seguir o padrão *@*.*", + _ => string.Empty + }; + + if (!string.IsNullOrEmpty(error)) + { + return Output.InvalidInput([error]); + } + + return Output.Created(new Email(value)); + } +} diff --git a/src/Shared/Contracts/Output.cs b/src/Shared/Contracts/Output.cs index c9e3d88..2061ab6 100644 --- a/src/Shared/Contracts/Output.cs +++ b/src/Shared/Contracts/Output.cs @@ -31,6 +31,10 @@ public Output(Output result) } #region Success + + public static Output Ok(IEnumerable? messages = null) => + new(OutputStatus.Ok, messages ?? []); + public static Output Created(IEnumerable? messages = null) => new(OutputStatus.Created, messages ?? []); @@ -41,8 +45,8 @@ public static Output Created(IEnumerable? messages = null) => public static Output UnexpectedError(IEnumerable messages) => new(OutputStatus.UnexpectedError, messages); - public static Output BusinessLogicViolation(IEnumerable messages) => - new(OutputStatus.BusinessLogicViolation, messages); + public static Output PolicyViolation(IEnumerable messages) => + new(OutputStatus.PolicyViolation, messages); public static Output InvalidInput(IEnumerable messages) => new(OutputStatus.InvalidInput, messages); @@ -86,8 +90,8 @@ public static Output InvalidInput(IEnumerable messages, TValue? public static Output NotFound(IEnumerable messages, TValue? value = default) => new(value, OutputStatus.NotFound, messages); - public static Output BusinessLogicViolation(IEnumerable messages, TValue? value = default) => - new(value, OutputStatus.BusinessLogicViolation, messages); + public static Output PolicyViolation(IEnumerable messages, TValue? value = default) => + new(value, OutputStatus.PolicyViolation, messages); public static Output UnexpectedError(IEnumerable messages, TValue? value = default) => new(value, OutputStatus.UnexpectedError, messages); diff --git a/src/Shared/Contracts/OutputStatus.cs b/src/Shared/Contracts/OutputStatus.cs index 59ae8b1..249a93f 100644 --- a/src/Shared/Contracts/OutputStatus.cs +++ b/src/Shared/Contracts/OutputStatus.cs @@ -33,7 +33,7 @@ public enum OutputStatus /// /// Business logic violation /// - BusinessLogicViolation, + PolicyViolation, /// /// Unexpected internal error diff --git a/src/Shared/Kairos.Shared.csproj b/src/Shared/Kairos.Shared.csproj index 8cfef2f..8d75705 100644 --- a/src/Shared/Kairos.Shared.csproj +++ b/src/Shared/Kairos.Shared.csproj @@ -10,7 +10,12 @@ + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + diff --git a/tests/Account.UnitTests/Business/UseCases/ConfirmEmailUseCaseTests.cs b/tests/Account.UnitTests/Business/UseCases/ConfirmEmailUseCaseTests.cs new file mode 100644 index 0000000..a9534e3 --- /dev/null +++ b/tests/Account.UnitTests/Business/UseCases/ConfirmEmailUseCaseTests.cs @@ -0,0 +1,128 @@ +using AutoFixture; +using FluentAssertions; +using Kairos.Account.Business.UseCases; +using Kairos.Account.Domain; +using Kairos.Shared.Contracts.Account; +using Kairos.Shared.Enums; +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.Logging; +using NSubstitute; +using NSubstitute.ExceptionExtensions; + +namespace Kairos.Account.UnitTests.Business.UseCases; + +public sealed class ConfirmEmailUseCaseTests +{ + readonly ILogger _logger; + readonly UserManager _identity; + readonly ConfirmEmailUseCase _sut; + readonly Fixture _fixture; + + public ConfirmEmailUseCaseTests() + { + _logger = Substitute.For>(); + _identity = MockUserManager(); + _sut = new ConfirmEmailUseCase(_logger, _identity); + _fixture = new Fixture(); + } + + static UserManager MockUserManager() + { + var store = Substitute.For>(); + return Substitute.For>(store, null, null, null, null, null, null, null, null); + } + + [Fact] + public async Task Handle_ShouldReturnOk_WhenAccountAndTokenAreValid() + { + // Arrange + var command = _fixture.Create(); + + var investor = Investor.OpenAccount("Test", "12378398202", "45692789302", "test@test.com", DateTime.UtcNow.AddYears(-20), true).Value!; + investor.Id = command.AccountId; + + _identity.FindByIdAsync(command.AccountId.ToString()).Returns(investor); + _identity.ConfirmEmailAsync(investor, command.ConfirmationToken).Returns(IdentityResult.Success); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.Ok); + result.Messages.Should().Contain("E-mail confirmado com sucesso!"); + await _identity.Received(1).ConfirmEmailAsync(investor, command.ConfirmationToken); + } + + [Theory] + [InlineData(0, "valid-token")] + [InlineData(1, "")] + [InlineData(1, null)] + public async Task Handle_ShouldReturnInvalidInput_WhenCommandIsInvalid(long accountId, string? token) + { + // Arrange + var command = new ConfirmEmailCommand(accountId, token!, Guid.NewGuid()); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.InvalidInput); + result.Messages.Should().Contain("A conta e seu token de confirmação devem ser especificados."); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenAccountNotFound() + { + // Arrange + var command = _fixture.Create(); + _identity.FindByIdAsync(command.AccountId.ToString()).Returns((Investor)null!); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain($"A conta {command.AccountId} não existe."); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenConfirmationFails() + { + // Arrange + var command = _fixture.Create(); + + var investor = Investor.OpenAccount( + "Test", "12378398202", "45692789302", "test@test.com", DateTime.UtcNow.AddYears(-20), true).Value!; + investor.Id = command.AccountId; + + var identityError = new IdentityError { Description = "Invalid token." }; + + _identity.FindByIdAsync(Arg.Any()).Returns(investor); + _identity.ConfirmEmailAsync(investor, command.ConfirmationToken) + .Returns(IdentityResult.Failed(identityError)); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("Invalid token."); + } + + [Fact] + public async Task Handle_ShouldReturnUnexpectedError_WhenIdentityThrowsException() + { + // Arrange + var command = _fixture.Create(); + var exception = new InvalidOperationException("Database error"); + + _identity.FindByIdAsync(command.AccountId.ToString()).ThrowsAsync(exception); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.UnexpectedError); + result.Messages.Should().Contain(exception.Message); + } +} \ No newline at end of file diff --git a/tests/Account.UnitTests/Business/UseCases/OpenAccountUseCaseTests.cs b/tests/Account.UnitTests/Business/UseCases/OpenAccountUseCaseTests.cs index 47996fb..11d5127 100644 --- a/tests/Account.UnitTests/Business/UseCases/OpenAccountUseCaseTests.cs +++ b/tests/Account.UnitTests/Business/UseCases/OpenAccountUseCaseTests.cs @@ -1,45 +1,170 @@ +using AutoFixture; using FluentAssertions; using Kairos.Account.Business.UseCases; +using Kairos.Account.Domain; +using Kairos.Account.Infra; using Kairos.Shared.Contracts.Account; using Kairos.Shared.Enums; using MassTransit; +using Microsoft.AspNetCore.Identity; +using Microsoft.EntityFrameworkCore; using Microsoft.Extensions.Logging; using NSubstitute; +using NSubstitute.ExceptionExtensions; namespace Kairos.Account.UnitTests.Business.UseCases; public sealed class OpenAccountUseCaseTests { - readonly IBus _bus = Substitute.For(); - readonly ILogger _logger = Substitute.For>(); + readonly ILogger _logger; + readonly IBus _bus; + readonly UserManager _identity; + readonly AccountContext _db; readonly OpenAccountUseCase _sut; + readonly Fixture _fixture; - public OpenAccountUseCaseTests() => _sut = new(_logger, _bus); + public OpenAccountUseCaseTests() + { + _logger = Substitute.For>(); + _bus = Substitute.For(); + _identity = MockUserManager(); + + var options = new DbContextOptionsBuilder() + .UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()) + .Options; + _db = new AccountContext(options); + + _sut = new OpenAccountUseCase(_logger, _bus, _identity, _db); + + _fixture = new Fixture(); + _fixture.Customize(composer => + composer.With(c => c.AcceptTerms, true) + .With(c => c.Birthdate, DateTime.UtcNow.AddYears(-19)) + .With(c => c.Email, "gustax.dev@outlook.com") + .With(c => c.PhoneNumber, "11994977777") + .With(c => c.Document, "77283890273")); + } - [Fact(DisplayName = "Open Account - Happy path")] - public async Task OpenAccount_HappyPath() + private static UserManager MockUserManager() { - // Arrange - var ct = TestContext.Current.CancellationToken; + var store = Substitute.For>(); + var userManager = Substitute.For>(store, null, null, null, null, null, null, null, null); + + userManager.CreateAsync(Arg.Any()).Returns(IdentityResult.Success); + + userManager.GenerateEmailConfirmationTokenAsync(Arg.Any()).Returns("email-token"); + userManager.GeneratePasswordResetTokenAsync(Arg.Any()).Returns("password-token"); + + return userManager; + } - OpenAccount command = new( - "Foo", - "Bar", - "51625637263", - "foo.bar@baz.com", - DateTime.Today, - true, - Guid.NewGuid()); + [Fact] + public async Task Handle_ShouldReturnCreated_WhenCommandIsValidAndIdentifiersAreUnique() + { + // Arrange + var command = _fixture.Build() + .With(c => c.AcceptTerms, true) + .With(c => c.Birthdate, DateTime.UtcNow.AddYears(-19)) + .With(c => c.Email, "gustax.dev@outlook.com") + .With(c => c.PhoneNumber, "11994977777") + .With(c => c.Document, "77283890273") + .Create(); // Act - var output = await _sut.Handle(command, ct); + var result = await _sut.Handle(command, default); // Assert - output.Status.Should().Be(OutputStatus.Created); + result.Status.Should().Be(OutputStatus.Created); + result.Messages.Should().Contain(m => m.Contains("aberta")); + await _identity.Received(1).CreateAsync(Arg.Is(i => i.Email == command.Email)); await _bus.Received().Publish( Arg.Is(e => e.Document == command.Document), Arg.Any>>(), cancellationToken: Arg.Any()); } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenEmailIsAlreadyInUse() + { + // Arrange + var openAccountResult = Investor.OpenAccount( + "Existing User", "55388899922", "11999998888", "taken@email.com", + DateTime.UtcNow.AddYears(-30), true); + var existingInvestor = openAccountResult.Value!; + + _db.Investors.Add(existingInvestor); + await _db.SaveChangesAsync(); + + var command = _fixture.Build() + .With(c => c.Email, "taken@email.com") + .Create(); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("O e-mail, telefone e/ou documento já está(ão) em uso."); + + await _identity.DidNotReceive().CreateAsync(Arg.Any()); + await _bus.DidNotReceiveWithAnyArgs().Publish(default!); + } + + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenUserIsUnderage() + { + // Arrange + var command = _fixture.Build() + .With(c => c.Birthdate, DateTime.UtcNow.AddYears(-17)) + .With(c => c.AcceptTerms, true) + .Create(); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("É necessário ser maior de idade para abrir a conta."); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenIdentityCreationFails() + { + // Arrange + var command = _fixture.Create(); + + var identityError = new IdentityError { Description = "Password is too weak." }; + _identity.CreateAsync(Arg.Any()).Returns(IdentityResult.Failed(identityError)); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("Password is too weak."); + + await _bus.DidNotReceiveWithAnyArgs().Publish(default!); + } + + [Fact] + public async Task Handle_ShouldReturnUnexpectedError_WhenDatabaseThrowsException() + { + // Arrange + var command = _fixture.Create(); + + var options = new DbContextOptionsBuilder().Options; + var dbContextMock = Substitute.For(options); + dbContextMock.Investors.Returns(_ => { throw new Exception("Database connection failed"); }); + + var sutWithBadDb = new OpenAccountUseCase(_logger, _bus, _identity, dbContextMock); + + // Act + var result = await sutWithBadDb.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.UnexpectedError); + result.Messages.Should().Contain("Database connection failed"); + } } \ No newline at end of file diff --git a/tests/Account.UnitTests/Business/UseCases/SetPasswordUseCaseTests.cs b/tests/Account.UnitTests/Business/UseCases/SetPasswordUseCaseTests.cs new file mode 100644 index 0000000..c1bd1e9 --- /dev/null +++ b/tests/Account.UnitTests/Business/UseCases/SetPasswordUseCaseTests.cs @@ -0,0 +1,129 @@ +using AutoFixture; +using FluentAssertions; +using Kairos.Account.Business.UseCases; +using Kairos.Account.Domain; +using Kairos.Shared.Contracts.Account; +using Kairos.Shared.Enums; +using Microsoft.AspNetCore.Identity; +using Microsoft.Extensions.Logging; +using NSubstitute; +using NSubstitute.ExceptionExtensions; + +namespace Kairos.Account.UnitTests.Business.UseCases; + +public sealed class SetPasswordUseCaseTests +{ + readonly ILogger _logger; + readonly UserManager _identity; + readonly SetPasswordUseCase _sut; + readonly Fixture _fixture; + + public SetPasswordUseCaseTests() + { + _logger = Substitute.For>(); + _identity = MockUserManager(); + _sut = new SetPasswordUseCase(_identity, _logger); + _fixture = new Fixture(); + } + + private static UserManager MockUserManager() + { + var store = Substitute.For>(); + return Substitute.For>(store, null, null, null, null, null, null, null, null); + } + + [Fact] + public async Task Handle_ShouldReturnOk_WhenCommandIsValid() + { + // Arrange + var command = _fixture.Create(); + var investor = Investor.OpenAccount("Test", "12345678901", "11987654321", "test@test.com", DateTime.UtcNow.AddYears(-25), true).Value!; + investor.Id = command.AccountId; + + _identity.FindByIdAsync(command.AccountId.ToString()).Returns(investor); + _identity.IsEmailConfirmedAsync(investor).Returns(true); + _identity.ResetPasswordAsync(investor, command.Token, command.Pass).Returns(IdentityResult.Success); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.Ok); + result.Messages.Should().Contain("Senha definida com sucesso!"); + await _identity.Received(1).ResetPasswordAsync(investor, command.Token, command.Pass); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenAccountNotFound() + { + // Arrange + var command = _fixture.Create(); + _identity.FindByIdAsync(command.AccountId.ToString()).Returns((Investor)null!); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain($"A conta #{command.AccountId} não existe."); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenEmailIsNotConfirmed() + { + // Arrange + var command = _fixture.Create(); + var investor = Investor.OpenAccount("Test", "12345678901", "11987654321", "test@test.com", DateTime.UtcNow.AddYears(-25), true).Value!; + investor.Id = command.AccountId; + + _identity.FindByIdAsync(command.AccountId.ToString()).Returns(investor); + _identity.IsEmailConfirmedAsync(investor).Returns(false); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("O e-mail da conta precisa ser confirmado primeiro."); + await _identity.DidNotReceive().ResetPasswordAsync(Arg.Any(), Arg.Any(), Arg.Any()); + } + + [Fact] + public async Task Handle_ShouldReturnPolicyViolation_WhenTokenIsInvalid() + { + // Arrange + var command = _fixture.Create(); + var investor = Investor.OpenAccount("Test", "12345678901", "11987654321", "test@test.com", DateTime.UtcNow.AddYears(-25), true).Value!; + investor.Id = command.AccountId; + var identityError = new IdentityError { Description = "Invalid token." }; + + _identity.FindByIdAsync(command.AccountId.ToString()).Returns(investor); + _identity.IsEmailConfirmedAsync(investor).Returns(true); + _identity.ResetPasswordAsync(investor, command.Token, command.Pass) + .Returns(IdentityResult.Failed(identityError)); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.PolicyViolation); + result.Messages.Should().Contain("Invalid token."); + } + + [Fact] + public async Task Handle_ShouldReturnUnexpectedError_WhenIdentityThrowsException() + { + // Arrange + var command = _fixture.Create(); + var exception = new InvalidOperationException("Database connection failed"); + + _identity.FindByIdAsync(command.AccountId.ToString()).ThrowsAsync(exception); + + // Act + var result = await _sut.Handle(command, default); + + // Assert + result.Status.Should().Be(OutputStatus.UnexpectedError); + result.Messages.Should().Contain(exception.Message); + } +} \ No newline at end of file diff --git a/tests/Account.UnitTests/Kairos.Account.UnitTests.csproj b/tests/Account.UnitTests/Kairos.Account.UnitTests.csproj index 5790192..9e75038 100644 --- a/tests/Account.UnitTests/Kairos.Account.UnitTests.csproj +++ b/tests/Account.UnitTests/Kairos.Account.UnitTests.csproj @@ -20,6 +20,8 @@ + +