diff --git a/Directory.Packages.props b/Directory.Packages.props index e889fae..6a877df 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -18,6 +18,8 @@ + + @@ -41,6 +43,8 @@ + + diff --git a/TaskFlow.slnx b/TaskFlow.slnx index 32b160c..9d484db 100644 --- a/TaskFlow.slnx +++ b/TaskFlow.slnx @@ -4,6 +4,7 @@ + @@ -18,8 +19,15 @@ + + + + + + + diff --git a/dotnet-tools.json b/dotnet-tools.json new file mode 100644 index 0000000..5c1165b --- /dev/null +++ b/dotnet-tools.json @@ -0,0 +1,13 @@ +{ + "version": 1, + "isRoot": true, + "tools": { + "dotnet-ef": { + "version": "10.0.12", + "commands": [ + "dotnet-ef" + ], + "rollForward": false + } + } +} \ No newline at end of file diff --git a/src/AppHost/TaskFlow.AppHost/AppHost.cs b/src/AppHost/TaskFlow.AppHost/AppHost.cs index 30bad8f..7cd3afb 100644 --- a/src/AppHost/TaskFlow.AppHost/AppHost.cs +++ b/src/AppHost/TaskFlow.AppHost/AppHost.cs @@ -8,6 +8,7 @@ // Une base par service : aucun service ne lit la base d'un autre. var projectsDb = postgres.AddDatabase("projectsdb"); +var tasksDb = postgres.AddDatabase("tasksdb"); // Broker de messages. Le plugin "management" ajoute l'interface web (files, débits, messages en attente). var rabbitmq = builder.AddRabbitMQ("rabbitmq") @@ -24,11 +25,21 @@ .WaitFor(rabbitmq) .WithHttpHealthCheck("/health"); +// Tasks écoute les événements de Projects via RabbitMQ : aucune référence directe entre les deux services. +var tasksApi = builder.AddProject("tasks-api") + .WithReference(tasksDb) + .WithReference(rabbitmq) + .WaitFor(tasksDb) + .WaitFor(rabbitmq) + .WithHttpHealthCheck("/health"); + // ── Gateway : seul point d'entrée du front ── var gateway = builder.AddProject("gateway") .WithReference(projectsApi) + .WithReference(tasksApi) .WaitFor(projectsApi) + .WaitFor(tasksApi) .WithHttpHealthCheck("/health"); // ── Front Angular : ne connaît que la Gateway ── diff --git a/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj b/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj index 9151bcf..bab6f80 100644 --- a/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj +++ b/src/AppHost/TaskFlow.AppHost/TaskFlow.AppHost.csproj @@ -15,6 +15,7 @@ + diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs b/src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs similarity index 64% rename from src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs rename to src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs index 2d2d17f..8a3ccc2 100644 --- a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/GlobalExceptionHandler.cs +++ b/src/BuildingBlocks/TaskFlow.Api.Common/GlobalExceptionHandler.cs @@ -1,17 +1,30 @@ using Microsoft.AspNetCore.Diagnostics; +using Microsoft.AspNetCore.Http; +using Microsoft.Extensions.Logging; -namespace TaskFlow.Projects.Api.Infrastructure; +namespace TaskFlow.Api.Common; /// /// Filet de sécurité pour les exceptions non prévues : log complet côté serveur, /// réponse 500 générique côté client (aucun détail technique exposé). /// -internal sealed partial class GlobalExceptionHandler( +public sealed partial class GlobalExceptionHandler( IProblemDetailsService problemDetailsService, ILogger logger) : IExceptionHandler { public async ValueTask TryHandleAsync(HttpContext httpContext, Exception exception, CancellationToken cancellationToken) { + // Requête mal formée (JSON invalide, corps illisible...) : c'est une erreur du CLIENT -> 400, pas 500. + if (exception is BadHttpRequestException badRequest) + { + httpContext.Response.StatusCode = badRequest.StatusCode; + return await problemDetailsService.TryWriteAsync(new ProblemDetailsContext + { + HttpContext = httpContext, + ProblemDetails = { Title = "Requête invalide.", Status = badRequest.StatusCode }, + }); + } + LogUnhandledException(logger, httpContext.Request.Path, exception); httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError; diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs b/src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs similarity index 94% rename from src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs rename to src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs index b672245..cc367d6 100644 --- a/src/Services/Projects/TaskFlow.Projects.Api/Infrastructure/ResultExtensions.cs +++ b/src/BuildingBlocks/TaskFlow.Api.Common/ResultExtensions.cs @@ -1,6 +1,7 @@ +using Microsoft.AspNetCore.Http; using TaskFlow.SharedKernel; -namespace TaskFlow.Projects.Api.Infrastructure; +namespace TaskFlow.Api.Common; /// /// Traduit un en échec vers une réponse HTTP ProblemDetails. diff --git a/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj b/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj new file mode 100644 index 0000000..d8518d0 --- /dev/null +++ b/src/BuildingBlocks/TaskFlow.Api.Common/TaskFlow.Api.Common.csproj @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs b/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs new file mode 100644 index 0000000..9eaa534 --- /dev/null +++ b/src/BuildingBlocks/TaskFlow.Api.Common/ValidationExtensions.cs @@ -0,0 +1,17 @@ +using FluentValidation; +using Microsoft.AspNetCore.Http; + +namespace TaskFlow.Api.Common; + +public static class ValidationExtensions +{ + /// + /// Valide une requête avec son validator FluentValidation. + /// Renvoie null si elle est valide, sinon une réponse 400 ValidationProblem listant les erreurs par champ. + /// + public static async Task ValidateRequestAsync(this IValidator validator, T request, CancellationToken ct) + { + var result = await validator.ValidateAsync(request, ct); + return result.IsValid ? null : TypedResults.ValidationProblem(result.ToDictionary()); + } +} diff --git a/src/Gateway/TaskFlow.Gateway/appsettings.json b/src/Gateway/TaskFlow.Gateway/appsettings.json index d640cc5..7952be6 100644 --- a/src/Gateway/TaskFlow.Gateway/appsettings.json +++ b/src/Gateway/TaskFlow.Gateway/appsettings.json @@ -12,6 +12,14 @@ "projects": { "ClusterId": "projects", "Match": { "Path": "/api/projects/{**catch-all}" } + }, + "projects-root": { + "ClusterId": "projects", + "Match": { "Path": "/api/projects" } + }, + "tasks": { + "ClusterId": "tasks", + "Match": { "Path": "/api/tasks/{**catch-all}" } } }, "Clusters": { @@ -19,6 +27,11 @@ "Destinations": { "projects-api": { "Address": "https+http://projects-api" } } + }, + "tasks": { + "Destinations": { + "tasks-api": { "Address": "https+http://tasks-api" } + } } } } diff --git a/src/Services/Projects/TaskFlow.Projects.Api/Program.cs b/src/Services/Projects/TaskFlow.Projects.Api/Program.cs index 0fdfcd2..1f5100b 100644 --- a/src/Services/Projects/TaskFlow.Projects.Api/Program.cs +++ b/src/Services/Projects/TaskFlow.Projects.Api/Program.cs @@ -1,16 +1,34 @@ using Scalar.AspNetCore; +using TaskFlow.Api.Common; using TaskFlow.Projects.Api.Infrastructure; +using TaskFlow.Projects.Contracts; using TaskFlow.Projects.Infrastructure; +using Wolverine; +using Wolverine.RabbitMQ; var builder = WebApplication.CreateBuilder(args); // Aspire : OpenTelemetry, health checks, service discovery, résilience HTTP. builder.AddServiceDefaults(); -// Connexion RabbitMQ injectée par l'AppHost : ajoute health check et traces. -// (À l'étape 2, Wolverine utilisera cette même connexion pour publier les événements.) +// Client RabbitMQ Aspire : health check "RabbitMQ" visible dans /health. builder.AddRabbitMQClient("rabbitmq"); +// Wolverine : bus de messages. Ce service PUBLIE, il n'écoute aucune queue pour l'instant. +builder.Host.UseWolverine(opts => +{ + var rabbitMq = builder.Configuration.GetConnectionString("rabbitmq") + ?? throw new InvalidOperationException("Chaîne de connexion 'rabbitmq' absente : lancer via l'AppHost Aspire."); + + opts.UseRabbitMq(new Uri(rabbitMq)) + // Crée les exchanges/queues déclarés s'ils n'existent pas encore. + .AutoProvision() + // Fanout : chaque service abonné reçoit sa propre copie de l'événement. + .DeclareExchange(ProjectsExchanges.ProjectCreated, exchange => exchange.ExchangeType = ExchangeType.Fanout); + + opts.PublishMessage().ToRabbitExchange(ProjectsExchanges.ProjectCreated); +}); + // Erreurs au format standard ProblemDetails (RFC 9457). builder.Services.AddProblemDetails(); builder.Services.AddExceptionHandler(); @@ -21,6 +39,11 @@ var app = builder.Build(); +if (app.Environment.IsDevelopment()) +{ + await app.Services.MigrateProjectsDatabaseAsync(); +} + app.UseExceptionHandler(); app.UseStatusCodePages(); @@ -36,4 +59,4 @@ app.MapInfoEndpoint(); app.MapProjectsModule(); -app.Run(); +await app.RunAsync(); diff --git a/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj b/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj index 7c4dddc..04ddd87 100644 --- a/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj +++ b/src/Services/Projects/TaskFlow.Projects.Api/TaskFlow.Projects.Api.csproj @@ -3,15 +3,14 @@ - - all - runtime; build; native; contentfiles; analyzers; buildtransitive - + + + diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs b/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs new file mode 100644 index 0000000..db42f29 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Application/Abstractions/IProjectRepository.cs @@ -0,0 +1,16 @@ +using TaskFlow.Projects.Domain; + +namespace TaskFlow.Projects.Application.Abstractions; + +/// +/// Port de persistance défini par l'Application, implémenté par l'Infrastructure (EF Core). +/// L'Application ne connaît donc ni EF Core ni Postgres. +/// +public interface IProjectRepository +{ + void Add(Project project); + + Task> ListAsync(CancellationToken ct); + + Task SaveChangesAsync(CancellationToken ct); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs b/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs index 4c6bea9..30f88d8 100644 --- a/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs +++ b/src/Services/Projects/TaskFlow.Projects.Application/DependencyInjection.cs @@ -1,5 +1,6 @@ using FluentValidation; using Microsoft.Extensions.DependencyInjection; +using TaskFlow.Projects.Application.Features; namespace TaskFlow.Projects.Application; @@ -10,8 +11,9 @@ public static IServiceCollection AddProjectsApplication(this IServiceCollection // Enregistre automatiquement tous les AbstractValidator du module. services.AddValidatorsFromAssembly(typeof(DependencyInjection).Assembly, includeInternalTypes: true); - // TODO (toi) : enregistrer ici les handlers de tes features, ex. - // services.AddScoped(); + // Un handler par feature qui modifie l'état. + services.AddScoped(); + return services; } } diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs b/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs new file mode 100644 index 0000000..2515536 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Application/Features/CreateProject.cs @@ -0,0 +1,71 @@ +using FluentValidation; +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Routing; +using TaskFlow.Api.Common; +using TaskFlow.Projects.Application.Abstractions; +using TaskFlow.Projects.Contracts; +using TaskFlow.Projects.Domain; +using TaskFlow.SharedKernel; +using Wolverine; + +namespace TaskFlow.Projects.Application.Features; + +/// +/// Vertical slice « créer un projet » : requête, validation, traitement et endpoint au même endroit. +/// POST /api/projects { "name": "Refonte du site" } +/// +public static class CreateProject +{ + public sealed record Command(string Name); + + public sealed record Response(Guid Id, string Name, DateTimeOffset CreatedAt); + + /// Validation de FORME (champ présent, longueur). Les règles MÉTIER restent dans l'agrégat. + public sealed class Validator : AbstractValidator + { + public Validator() + { + RuleFor(c => c.Name).NotEmpty().MaximumLength(Project.NameMaxLength); + } + } + + public sealed class Handler(IProjectRepository projects, IMessageBus bus, TimeProvider clock) + { + public async Task> Handle(Command command, CancellationToken ct) + { + var created = Project.Create(command.Name, clock.GetUtcNow()); + if (created.IsFailure) + { + return created.Error; + } + + var project = created.Value; + projects.Add(project); + await projects.SaveChangesAsync(ct); + + // Informe les autres services (Tasks créera le board du projet). + // ⚠ Sans outbox, un crash entre SaveChanges et PublishAsync perdrait l'événement : + // c'est exactement ce que l'étape 3 corrige (outbox Wolverine, même transaction). + await bus.PublishAsync(new ProjectCreated(project.Id.Value, project.Name, project.CreatedAt)); + + return new Response(project.Id.Value, project.Name, project.CreatedAt); + } + } + + public static void Map(RouteGroupBuilder group) => + group.MapPost("/", async Task (Command command, IValidator validator, Handler handler, CancellationToken ct) => + { + if (await validator.ValidateRequestAsync(command, ct) is { } invalid) + { + return invalid; + } + + var result = await handler.Handle(command, ct); + return result.IsSuccess + ? TypedResults.Created($"/api/projects/{result.Value.Id}", result.Value) + : result.ToProblem(); + }) + .WithName("CreateProject") + .WithSummary("Crée un projet et publie l'événement ProjectCreated sur RabbitMQ."); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs b/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs new file mode 100644 index 0000000..7f2a621 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Application/Features/GetProjects.cs @@ -0,0 +1,20 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Routing; +using TaskFlow.Projects.Application.Abstractions; + +namespace TaskFlow.Projects.Application.Features; + +/// GET /api/projects : liste des projets (du plus récent au plus ancien). +public static class GetProjects +{ + public sealed record Item(Guid Id, string Name, DateTimeOffset CreatedAt); + + public static void Map(RouteGroupBuilder group) => + group.MapGet("/", async (IProjectRepository projects, CancellationToken ct) => + { + var list = await projects.ListAsync(ct); + return TypedResults.Ok(list.Select(p => new Item(p.Id.Value, p.Name, p.CreatedAt)).ToList()); + }) + .WithName("GetProjects"); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs b/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs index f5c50e7..9fd83f9 100644 --- a/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs +++ b/src/Services/Projects/TaskFlow.Projects.Application/ProjectsEndpoints.cs @@ -1,20 +1,20 @@ using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.Routing; +using TaskFlow.Projects.Application.Features; namespace TaskFlow.Projects.Application; public static class ProjectsEndpoints { - /// Point d'entrée HTTP du module : toutes les routes vivent sous /api/projects. + /// Point d'entrée HTTP du service : toutes les routes vivent sous /api/projects. public static IEndpointRouteBuilder MapProjectsEndpoints(this IEndpointRouteBuilder app) { var group = app.MapGroup("/api/projects").WithTags("Projects"); - // TODO (toi) : une ligne par feature, ex. - // CreateProject.Endpoint.Map(group); - // GetProjects.Endpoint.Map(group); - _ = group; + // Une ligne par feature. + CreateProject.Map(group); + GetProjects.Map(group); return app; } diff --git a/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj b/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj index d861872..22e1f1a 100644 --- a/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj +++ b/src/Services/Projects/TaskFlow.Projects.Application/TaskFlow.Projects.Application.csproj @@ -1,12 +1,16 @@ - + + + + + diff --git a/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs b/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs new file mode 100644 index 0000000..2d30752 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Contracts/Messaging.cs @@ -0,0 +1,10 @@ +namespace TaskFlow.Projects.Contracts; + +/// +/// Noms des exchanges RabbitMQ sur lesquels le service Projects publie. +/// Un exchange "fanout" par type d'événement : chaque service abonné y lie SA propre queue. +/// +public static class ProjectsExchanges +{ + public const string ProjectCreated = "projects.project-created"; +} diff --git a/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs b/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs new file mode 100644 index 0000000..9df41a8 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Contracts/ProjectCreated.cs @@ -0,0 +1,10 @@ +namespace TaskFlow.Projects.Contracts; + +/// +/// Événement d'intégration publié sur RabbitMQ quand un projet est créé. +/// Contrat public : types simples uniquement, et on n'enlève ni ne renomme jamais un champ. +/// +/// Identifiant du projet (le même dans tous les services). +/// Nom du projet au moment de sa création. +/// Date de création, en UTC. +public sealed record ProjectCreated(Guid ProjectId, string Name, DateTimeOffset CreatedAt); diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs b/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs new file mode 100644 index 0000000..eef52e1 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Domain/Project.cs @@ -0,0 +1,46 @@ +using TaskFlow.SharedKernel; + +namespace TaskFlow.Projects.Domain; + +/// +/// Agrégat Projet. Toutes les règles métier vivent ici : les propriétés ne sont modifiables +/// que par des méthodes qui vérifient les invariants (pas de setter public). +/// +public sealed class Project : AggregateRoot +{ + public const int NameMaxLength = 100; + + private Project(ProjectId id, string name, DateTimeOffset createdAt) : base(id) + { + Name = name; + CreatedAt = createdAt; + } + + // Requis par EF Core. + private Project() { } + + public string Name { get; private set; } = string.Empty; + public DateTimeOffset CreatedAt { get; private init; } + + /// + /// Fabrique : seul moyen de créer un projet valide. Renvoie une erreur métier au lieu de lever une exception. + /// + public static Result Create(string name, DateTimeOffset now) + { + var trimmed = name?.Trim() ?? string.Empty; + + if (trimmed.Length == 0) + { + return ProjectErrors.NameRequired; + } + + if (trimmed.Length > NameMaxLength) + { + return ProjectErrors.NameTooLong; + } + + var project = new Project(ProjectId.New(), trimmed, now); + project.Raise(new ProjectCreatedDomainEvent(project.Id, project.Name)); + return project; + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs new file mode 100644 index 0000000..d94f1a9 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectCreatedDomainEvent.cs @@ -0,0 +1,10 @@ +using TaskFlow.SharedKernel; + +namespace TaskFlow.Projects.Domain; + +/// +/// Événement de DOMAINE : interne au service, porte des types du domaine (ProjectId). +/// À ne pas confondre avec l'événement d'INTÉGRATION TaskFlow.Projects.Contracts.ProjectCreated, +/// public et sérialisé sur RabbitMQ. +/// +public sealed record ProjectCreatedDomainEvent(ProjectId ProjectId, string Name) : DomainEvent; diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs new file mode 100644 index 0000000..50c8953 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectErrors.cs @@ -0,0 +1,13 @@ +using TaskFlow.SharedKernel; + +namespace TaskFlow.Projects.Domain; + +/// Erreurs métier du projet, avec un code stable que le front peut interpréter. +public static class ProjectErrors +{ + public static readonly Error NameRequired = + Error.Validation("Project.NameRequired", "Le nom du projet est obligatoire."); + + public static readonly Error NameTooLong = + Error.Validation("Project.NameTooLong", $"Le nom du projet ne peut pas dépasser {Project.NameMaxLength} caractères."); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs new file mode 100644 index 0000000..7692d0d --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Domain/ProjectId.cs @@ -0,0 +1,12 @@ +namespace TaskFlow.Projects.Domain; + +/// +/// Identifiant fortement typé : impossible de passer un TaskId là où on attend un ProjectId. +/// Guid v7 : triable par date de création, donc efficace comme clé d'index. +/// +public readonly record struct ProjectId(Guid Value) +{ + public static ProjectId New() => new(Guid.CreateVersion7()); + + public override string ToString() => Value.ToString(); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs new file mode 100644 index 0000000..0458a24 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/DesignTimeDbContextFactory.cs @@ -0,0 +1,20 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Design; + +namespace TaskFlow.Projects.Infrastructure.Persistence; + +/// +/// Utilisé UNIQUEMENT par "dotnet ef migrations add" : fournit un DbContext sans démarrer l'API +/// (dont la chaîne de connexion n'existe que lorsqu'Aspire la lance). Aucune connexion n'est ouverte. +/// +internal sealed class DesignTimeDbContextFactory : IDesignTimeDbContextFactory +{ + public ProjectsDbContext CreateDbContext(string[] args) + { + var options = new DbContextOptionsBuilder() + .UseNpgsql("Host=localhost;Database=projectsdb") + .Options; + + return new ProjectsDbContext(options); + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs new file mode 100644 index 0000000..7f437c3 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.Designer.cs @@ -0,0 +1,49 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; +using TaskFlow.Projects.Infrastructure.Persistence; + +#nullable disable + +namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations +{ + [DbContext(typeof(ProjectsDbContext))] + [Migration("20260929141945_InitialCreate")] + partial class InitialCreate + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("projects") + .HasAnnotation("ProductVersion", "10.0.12") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("TaskFlow.Projects.Domain.Project", b => + { + b.Property("Id") + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("Id"); + + b.ToTable("projects", "projects"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs new file mode 100644 index 0000000..12c6bfe --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/20260929141945_InitialCreate.cs @@ -0,0 +1,40 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations +{ + /// + public partial class InitialCreate : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.EnsureSchema( + name: "projects"); + + migrationBuilder.CreateTable( + name: "projects", + schema: "projects", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + Name = table.Column(type: "character varying(100)", maxLength: 100, nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_projects", x => x.Id); + }); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "projects", + schema: "projects"); + } + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs new file mode 100644 index 0000000..35c05a7 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/Migrations/ProjectsDbContextModelSnapshot.cs @@ -0,0 +1,46 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; +using TaskFlow.Projects.Infrastructure.Persistence; + +#nullable disable + +namespace TaskFlow.Projects.Infrastructure.Persistence.Migrations +{ + [DbContext(typeof(ProjectsDbContext))] + partial class ProjectsDbContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("projects") + .HasAnnotation("ProductVersion", "10.0.12") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("TaskFlow.Projects.Domain.Project", b => + { + b.Property("Id") + .HasColumnType("uuid"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("Name") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("Id"); + + b.ToTable("projects", "projects"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs new file mode 100644 index 0000000..476c190 --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectConfiguration.cs @@ -0,0 +1,30 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; +using TaskFlow.Projects.Domain; + +namespace TaskFlow.Projects.Infrastructure.Persistence; + +/// Mapping EF Core de l'agrégat : le domaine reste libre de tout attribut de persistance. +internal sealed class ProjectConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("projects"); + + builder.HasKey(p => p.Id); + + // Identifiant typé <-> uuid en base. + builder.Property(p => p.Id) + .HasConversion(id => id.Value, value => new ProjectId(value)) + .ValueGeneratedNever(); + + builder.Property(p => p.Name) + .HasMaxLength(Project.NameMaxLength) + .IsRequired(); + + builder.Property(p => p.CreatedAt).IsRequired(); + + // Les événements de domaine ne sont pas persistés. + builder.Ignore(p => p.DomainEvents); + } +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs new file mode 100644 index 0000000..cd8297f --- /dev/null +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectRepository.cs @@ -0,0 +1,16 @@ +using Microsoft.EntityFrameworkCore; +using TaskFlow.Projects.Application.Abstractions; +using TaskFlow.Projects.Domain; + +namespace TaskFlow.Projects.Infrastructure.Persistence; + +/// Public pour la même raison que BoardRepository (code généré par Wolverine). +public sealed class ProjectRepository(ProjectsDbContext db) : IProjectRepository +{ + public void Add(Project project) => db.Projects.Add(project); + + public async Task> ListAsync(CancellationToken ct) => + await db.Projects.AsNoTracking().OrderByDescending(p => p.CreatedAt).ToListAsync(ct); + + public Task SaveChangesAsync(CancellationToken ct) => db.SaveChangesAsync(ct); +} diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs index 1db9bbf..cd86e0c 100644 --- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/Persistence/ProjectsDbContext.cs @@ -1,16 +1,17 @@ using Microsoft.EntityFrameworkCore; +using TaskFlow.Projects.Domain; namespace TaskFlow.Projects.Infrastructure.Persistence; /// -/// DbContext propre au module Projects. Il écrit dans son propre schéma Postgres : -/// aucun autre module ne doit lire ces tables directement. +/// DbContext propre au service Projects, dans sa propre base (projectsdb) et son propre schéma. +/// Aucun autre service ne lit ces tables : ils reçoivent les événements à la place. /// public sealed class ProjectsDbContext(DbContextOptions options) : DbContext(options) { public const string Schema = "projects"; - // TODO (toi) : public DbSet Projects => Set(); + public DbSet Projects => Set(); protected override void OnModelCreating(ModelBuilder modelBuilder) { diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs b/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs index ac027e7..37f41f8 100644 --- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/ProjectsModule.cs @@ -1,11 +1,14 @@ using Microsoft.AspNetCore.Routing; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using TaskFlow.Projects.Application; +using TaskFlow.Projects.Application.Abstractions; using TaskFlow.Projects.Infrastructure.Persistence; namespace TaskFlow.Projects.Infrastructure; -/// Composition du module : l'API n'appelle que ces deux méthodes. +/// Composition du service : l'API n'appelle que ces méthodes. public static class ProjectsModule { /// Base propre au service Projects, déclarée dans l'AppHost (AddDatabase("projectsdb")). @@ -19,9 +22,23 @@ public static IHostApplicationBuilder AddProjectsModule(this IHostApplicationBui // et ajoute retries, health check et traces OpenTelemetry pour EF Core. builder.AddNpgsqlDbContext(DatabaseName); + builder.Services.AddScoped(); + builder.Services.AddSingleton(TimeProvider.System); + return builder; } public static IEndpointRouteBuilder MapProjectsModule(this IEndpointRouteBuilder app) => app.MapProjectsEndpoints(); + + /// + /// Applique les migrations EF Core au démarrage. Réservé au DÉVELOPPEMENT : + /// en production, les migrations passent par un bundle exécuté par la CI/CD. + /// + public static async Task MigrateProjectsDatabaseAsync(this IServiceProvider services) + { + await using var scope = services.CreateAsyncScope(); + var db = scope.ServiceProvider.GetRequiredService(); + await db.Database.MigrateAsync(); + } } diff --git a/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj b/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj index c4c854d..bc7167f 100644 --- a/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj +++ b/src/Services/Projects/TaskFlow.Projects.Infrastructure/TaskFlow.Projects.Infrastructure.csproj @@ -3,6 +3,11 @@ + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs new file mode 100644 index 0000000..bdb24fc --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/InfoEndpoint.cs @@ -0,0 +1,22 @@ +using System.Reflection; + +namespace TaskFlow.Tasks.Api; + +/// Endpoint technique : identité et version du service Tasks (exposé via la Gateway). +public static class InfoEndpoint +{ + public sealed record ServiceInfo(string Name, string Version, string Environment, DateTimeOffset ServerTime); + + public static IEndpointRouteBuilder MapInfoEndpoint(this IEndpointRouteBuilder app) + { + app.MapGet("/api/tasks/info", (IHostEnvironment env) => TypedResults.Ok(new ServiceInfo( + Name: "TaskFlow Tasks", + Version: Assembly.GetExecutingAssembly().GetName().Version?.ToString() ?? "0.0.0", + Environment: env.EnvironmentName, + ServerTime: DateTimeOffset.UtcNow))) + .WithName("GetTasksServiceInfo") + .WithTags("Info"); + + return app; + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs new file mode 100644 index 0000000..e3c35a5 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/Program.cs @@ -0,0 +1,73 @@ +using JasperFx.CodeGeneration.Model; +using Scalar.AspNetCore; +using TaskFlow.Api.Common; +using TaskFlow.Projects.Contracts; +using TaskFlow.Tasks.Api; +using TaskFlow.Tasks.Application.IntegrationEvents; +using TaskFlow.Tasks.Infrastructure; +using Wolverine; +using Wolverine.RabbitMQ; +using Wolverine.RabbitMQ.Internal; + +var builder = WebApplication.CreateBuilder(args); + +builder.AddServiceDefaults(); +builder.AddRabbitMQClient("rabbitmq"); + +// Wolverine : ce service ÉCOUTE les événements des autres services. +builder.Host.UseWolverine(opts => +{ + var rabbitMq = builder.Configuration.GetConnectionString("rabbitmq") + ?? throw new InvalidOperationException("Chaîne de connexion 'rabbitmq' absente : lancer via l'AppHost Aspire."); + + opts.UseRabbitMq(new Uri(rabbitMq)) + .AutoProvision() + // Même exchange que celui déclaré par Projects (la déclaration est idempotente), + // auquel on lie la queue PROPRE à Tasks : chaque service abonné a sa copie du message. + .DeclareExchange(ProjectsExchanges.ProjectCreated, exchange => + { + exchange.ExchangeType = ExchangeType.Fanout; + exchange.BindQueue(TasksQueues.ProjectCreated); + }); + + // Quorum queue : durable et répliquée, le type recommandé depuis RabbitMQ 4. + opts.ListenToRabbitQueue(TasksQueues.ProjectCreated, queue => queue.QueueType = QueueType.quorum); + + // Les handlers vivent dans la couche Application, pas dans l'API. + opts.Discovery.IncludeAssembly(typeof(ProjectCreatedHandler).Assembly); + + // Le DbContext est enregistré par Aspire via un pool (fabrique opaque) : Wolverine doit alors le + // demander au conteneur au lieu de l'instancier dans son code généré. Autorisé, avec un avertissement. + // (Étape 3 : l'intégration EF Core de Wolverine, installée pour l'outbox, supprimera ce besoin.) + opts.ServiceLocationPolicy = ServiceLocationPolicy.AllowedButWarn; +}); + +builder.Services.AddProblemDetails(); +builder.Services.AddExceptionHandler(); +builder.Services.AddOpenApi(); + +builder.AddTasksModule(); + +var app = builder.Build(); + +if (app.Environment.IsDevelopment()) +{ + await app.Services.MigrateTasksDatabaseAsync(); +} + +app.UseExceptionHandler(); +app.UseStatusCodePages(); + +if (app.Environment.IsDevelopment()) +{ + app.MapOpenApi(); + app.MapScalarApiReference(); +} + +app.UseHttpsRedirection(); + +app.MapDefaultEndpoints(); +app.MapInfoEndpoint(); +app.MapTasksModule(); + +await app.RunAsync(); diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json b/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json new file mode 100644 index 0000000..299951c --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/Properties/launchSettings.json @@ -0,0 +1,23 @@ +{ + "$schema": "https://json.schemastore.org/launchsettings.json", + "profiles": { + "http": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": true, + "applicationUrl": "http://localhost:5089", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + }, + "https": { + "commandName": "Project", + "dotnetRunMessages": true, + "launchBrowser": true, + "applicationUrl": "https://localhost:7141;http://localhost:5089", + "environmentVariables": { + "ASPNETCORE_ENVIRONMENT": "Development" + } + } + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj b/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj new file mode 100644 index 0000000..35fdcfd --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/TaskFlow.Tasks.Api.csproj @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs b/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs new file mode 100644 index 0000000..75145ee --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/TasksQueues.cs @@ -0,0 +1,9 @@ +namespace TaskFlow.Tasks.Api; + +/// +/// Queues RabbitMQ propres au service Tasks. Convention : "{service consommateur}.{événement}". +/// +public static class TasksQueues +{ + public const string ProjectCreated = "tasks.project-created"; +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json new file mode 100644 index 0000000..0c208ae --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.Development.json @@ -0,0 +1,8 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json new file mode 100644 index 0000000..10f68b8 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Api/appsettings.json @@ -0,0 +1,9 @@ +{ + "Logging": { + "LogLevel": { + "Default": "Information", + "Microsoft.AspNetCore": "Warning" + } + }, + "AllowedHosts": "*" +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs new file mode 100644 index 0000000..8cdc98d --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/Abstractions/IBoardRepository.cs @@ -0,0 +1,15 @@ +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.Application.Abstractions; + +/// Port de persistance des boards, implémenté par l'Infrastructure (EF Core). +public interface IBoardRepository +{ + Task ExistsForProjectAsync(Guid projectId, CancellationToken ct); + + void Add(Board board); + + Task> ListAsync(CancellationToken ct); + + Task SaveChangesAsync(CancellationToken ct); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs new file mode 100644 index 0000000..14145ca --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/DependencyInjection.cs @@ -0,0 +1,15 @@ +using FluentValidation; +using Microsoft.Extensions.DependencyInjection; + +namespace TaskFlow.Tasks.Application; + +public static class DependencyInjection +{ + public static IServiceCollection AddTasksApplication(this IServiceCollection services) + { + services.AddValidatorsFromAssembly(typeof(DependencyInjection).Assembly, includeInternalTypes: true); + + // Les handlers d'événements (ProjectCreatedHandler...) sont découverts et construits par Wolverine. + return services; + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs new file mode 100644 index 0000000..b6d9b29 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/Features/GetBoards.cs @@ -0,0 +1,22 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Routing; +using TaskFlow.Tasks.Application.Abstractions; + +namespace TaskFlow.Tasks.Application.Features; + +/// GET /api/tasks/boards : liste des boards (un par projet). +public static class GetBoards +{ + public sealed record Item(Guid Id, Guid ProjectId, string ProjectName, IReadOnlyList Columns, DateTimeOffset CreatedAt); + + public static void Map(RouteGroupBuilder group) => + group.MapGet("/boards", async (IBoardRepository boards, CancellationToken ct) => + { + var list = await boards.ListAsync(ct); + return TypedResults.Ok(list + .Select(b => new Item(b.Id.Value, b.ProjectId, b.ProjectName, b.Columns, b.CreatedAt)) + .ToList()); + }) + .WithName("GetBoards"); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs new file mode 100644 index 0000000..0f80cd4 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/IntegrationEvents/ProjectCreatedHandler.cs @@ -0,0 +1,38 @@ +using Microsoft.Extensions.Logging; +using TaskFlow.Projects.Contracts; +using TaskFlow.Tasks.Application.Abstractions; +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.Application.IntegrationEvents; + +/// +/// Réagit à l'événement ProjectCreated publié par le service Projects : crée le board du projet. +/// Wolverine le découvre par convention (classe "...Handler", méthode "Handle") ; aucune dépendance à Wolverine ici. +/// +public sealed partial class ProjectCreatedHandler( + IBoardRepository boards, + TimeProvider clock, + ILogger logger) +{ + public async Task Handle(ProjectCreated message, CancellationToken ct) + { + // IDEMPOTENCE : RabbitMQ garantit "au moins une fois", le même message peut arriver deux fois. + // Rejouer ce handler ne doit jamais créer un second board. + if (await boards.ExistsForProjectAsync(message.ProjectId, ct)) + { + LogAlreadyExists(logger, message.ProjectId); + return; + } + + boards.Add(Board.CreateForProject(message.ProjectId, message.Name, clock.GetUtcNow())); + await boards.SaveChangesAsync(ct); + + LogBoardCreated(logger, message.ProjectId, message.Name); + } + + [LoggerMessage(Level = LogLevel.Information, Message = "Board créé pour le projet {ProjectId} ({ProjectName})")] + private static partial void LogBoardCreated(ILogger logger, Guid projectId, string projectName); + + [LoggerMessage(Level = LogLevel.Information, Message = "Board déjà existant pour le projet {ProjectId} : message ignoré (idempotence)")] + private static partial void LogAlreadyExists(ILogger logger, Guid projectId); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj b/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj new file mode 100644 index 0000000..c8f8516 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/TaskFlow.Tasks.Application.csproj @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs b/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs new file mode 100644 index 0000000..017bb22 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Application/TasksEndpoints.cs @@ -0,0 +1,19 @@ +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Routing; +using TaskFlow.Tasks.Application.Features; + +namespace TaskFlow.Tasks.Application; + +public static class TasksEndpoints +{ + /// Point d'entrée HTTP du service : toutes les routes vivent sous /api/tasks. + public static IEndpointRouteBuilder MapTasksEndpoints(this IEndpointRouteBuilder app) + { + var group = app.MapGroup("/api/tasks").WithTags("Tasks"); + + GetBoards.Map(group); + + return app; + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs b/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs new file mode 100644 index 0000000..3dcc13a --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/Board.cs @@ -0,0 +1,40 @@ +using TaskFlow.SharedKernel; + +namespace TaskFlow.Tasks.Domain; + +/// +/// Board Kanban d'un projet. Un projet a exactement un board, créé automatiquement +/// quand le service Tasks reçoit l'événement ProjectCreated. +/// +public sealed class Board : AggregateRoot +{ + public static readonly IReadOnlyList DefaultColumns = ["À faire", "En cours", "Terminé"]; + + private readonly List _columns = []; + + private Board(BoardId id, Guid projectId, string projectName, DateTimeOffset createdAt) : base(id) + { + ProjectId = projectId; + ProjectName = projectName; + CreatedAt = createdAt; + _columns.AddRange(DefaultColumns); + } + + // Requis par EF Core. + private Board() { } + + /// + /// Référence au projet d'un AUTRE service : un simple Guid, jamais un objet du domaine Projects. + /// + public Guid ProjectId { get; private init; } + + /// Copie locale du nom du projet (cohérence éventuelle : mise à jour par événement). + public string ProjectName { get; private set; } = string.Empty; + + public DateTimeOffset CreatedAt { get; private init; } + + public IReadOnlyList Columns => _columns.AsReadOnly(); + + public static Board CreateForProject(Guid projectId, string projectName, DateTimeOffset now) => + new(BoardId.New(), projectId, projectName, now); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs b/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs new file mode 100644 index 0000000..9bf37d7 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/BoardId.cs @@ -0,0 +1,9 @@ +namespace TaskFlow.Tasks.Domain; + +/// Identifiant fortement typé du board (Guid v7). +public readonly record struct BoardId(Guid Value) +{ + public static BoardId New() => new(Guid.CreateVersion7()); + + public override string ToString() => Value.ToString(); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj b/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj new file mode 100644 index 0000000..0f551c3 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Domain/TaskFlow.Tasks.Domain.csproj @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs new file mode 100644 index 0000000..3c3c8fe --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardConfiguration.cs @@ -0,0 +1,33 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Metadata.Builders; +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.Infrastructure.Persistence; + +internal sealed class BoardConfiguration : IEntityTypeConfiguration +{ + public void Configure(EntityTypeBuilder builder) + { + builder.ToTable("boards"); + + builder.HasKey(b => b.Id); + + builder.Property(b => b.Id) + .HasConversion(id => id.Value, value => new BoardId(value)) + .ValueGeneratedNever(); + + // Un seul board par projet : l'index unique est la seconde barrière de l'idempotence + // (si deux messages identiques étaient traités en parallèle). + builder.HasIndex(b => b.ProjectId).IsUnique(); + + builder.Property(b => b.ProjectName).HasMaxLength(100).IsRequired(); + builder.Property(b => b.CreatedAt).IsRequired(); + + // Liste de colonnes stockée en JSON (primitive collection EF Core), via le champ privé _columns. + builder.PrimitiveCollection(b => b.Columns) + .HasField("_columns") + .UsePropertyAccessMode(PropertyAccessMode.Field); + + builder.Ignore(b => b.DomainEvents); + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs new file mode 100644 index 0000000..8c2c0df --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/BoardRepository.cs @@ -0,0 +1,23 @@ +using Microsoft.EntityFrameworkCore; +using TaskFlow.Tasks.Application.Abstractions; +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.Infrastructure.Persistence; + +/// +/// Public (et non internal) : le code que Wolverine génère pour ses handlers instancie directement +/// les dépendances. Avec un type internal, il devrait passer par le conteneur (service location), +/// ce que sa politique par défaut interdit : le message partirait en dead-letter queue. +/// +public sealed class BoardRepository(TasksDbContext db) : IBoardRepository +{ + public Task ExistsForProjectAsync(Guid projectId, CancellationToken ct) => + db.Boards.AnyAsync(b => b.ProjectId == projectId, ct); + + public void Add(Board board) => db.Boards.Add(board); + + public async Task> ListAsync(CancellationToken ct) => + await db.Boards.AsNoTracking().OrderByDescending(b => b.CreatedAt).ToListAsync(ct); + + public Task SaveChangesAsync(CancellationToken ct) => db.SaveChangesAsync(ct); +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs new file mode 100644 index 0000000..70163f5 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/DesignTimeDbContextFactory.cs @@ -0,0 +1,17 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Design; + +namespace TaskFlow.Tasks.Infrastructure.Persistence; + +/// Utilisé UNIQUEMENT par "dotnet ef migrations add" (aucune connexion n'est ouverte). +internal sealed class DesignTimeDbContextFactory : IDesignTimeDbContextFactory +{ + public TasksDbContext CreateDbContext(string[] args) + { + var options = new DbContextOptionsBuilder() + .UseNpgsql("Host=localhost;Database=tasksdb") + .Options; + + return new TasksDbContext(options); + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs new file mode 100644 index 0000000..856844a --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.Designer.cs @@ -0,0 +1,59 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; +using TaskFlow.Tasks.Infrastructure.Persistence; + +#nullable disable + +namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations +{ + [DbContext(typeof(TasksDbContext))] + [Migration("20260929142223_InitialCreate")] + partial class InitialCreate + { + /// + protected override void BuildTargetModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("tasks") + .HasAnnotation("ProductVersion", "10.0.12") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("TaskFlow.Tasks.Domain.Board", b => + { + b.Property("Id") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Columns") + .IsRequired() + .HasColumnType("text[]"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("ProjectId") + .HasColumnType("uuid"); + + b.Property("ProjectName") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("Id"); + + b.HasIndex("ProjectId") + .IsUnique(); + + b.ToTable("boards", "tasks"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs new file mode 100644 index 0000000..6970062 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/20260929142223_InitialCreate.cs @@ -0,0 +1,49 @@ +using System; +using Microsoft.EntityFrameworkCore.Migrations; + +#nullable disable + +namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations +{ + /// + public partial class InitialCreate : Migration + { + /// + protected override void Up(MigrationBuilder migrationBuilder) + { + migrationBuilder.EnsureSchema( + name: "tasks"); + + migrationBuilder.CreateTable( + name: "boards", + schema: "tasks", + columns: table => new + { + Id = table.Column(type: "uuid", nullable: false), + ProjectId = table.Column(type: "uuid", nullable: false), + ProjectName = table.Column(type: "character varying(100)", maxLength: 100, nullable: false), + CreatedAt = table.Column(type: "timestamp with time zone", nullable: false), + Columns = table.Column(type: "text[]", nullable: false) + }, + constraints: table => + { + table.PrimaryKey("PK_boards", x => x.Id); + }); + + migrationBuilder.CreateIndex( + name: "IX_boards_ProjectId", + schema: "tasks", + table: "boards", + column: "ProjectId", + unique: true); + } + + /// + protected override void Down(MigrationBuilder migrationBuilder) + { + migrationBuilder.DropTable( + name: "boards", + schema: "tasks"); + } + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs new file mode 100644 index 0000000..8c75026 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/Migrations/TasksDbContextModelSnapshot.cs @@ -0,0 +1,56 @@ +// +using System; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata; +using TaskFlow.Tasks.Infrastructure.Persistence; + +#nullable disable + +namespace TaskFlow.Tasks.Infrastructure.Persistence.Migrations +{ + [DbContext(typeof(TasksDbContext))] + partial class TasksDbContextModelSnapshot : ModelSnapshot + { + protected override void BuildModel(ModelBuilder modelBuilder) + { +#pragma warning disable 612, 618 + modelBuilder + .HasDefaultSchema("tasks") + .HasAnnotation("ProductVersion", "10.0.12") + .HasAnnotation("Relational:MaxIdentifierLength", 63); + + NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder); + + modelBuilder.Entity("TaskFlow.Tasks.Domain.Board", b => + { + b.Property("Id") + .HasColumnType("uuid"); + + b.PrimitiveCollection("Columns") + .IsRequired() + .HasColumnType("text[]"); + + b.Property("CreatedAt") + .HasColumnType("timestamp with time zone"); + + b.Property("ProjectId") + .HasColumnType("uuid"); + + b.Property("ProjectName") + .IsRequired() + .HasMaxLength(100) + .HasColumnType("character varying(100)"); + + b.HasKey("Id"); + + b.HasIndex("ProjectId") + .IsUnique(); + + b.ToTable("boards", "tasks"); + }); +#pragma warning restore 612, 618 + } + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs new file mode 100644 index 0000000..60a2e3f --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/Persistence/TasksDbContext.cs @@ -0,0 +1,18 @@ +using Microsoft.EntityFrameworkCore; +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.Infrastructure.Persistence; + +/// DbContext propre au service Tasks, dans sa propre base (tasksdb) et son propre schéma. +public sealed class TasksDbContext(DbContextOptions options) : DbContext(options) +{ + public const string Schema = "tasks"; + + public DbSet Boards => Set(); + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + modelBuilder.HasDefaultSchema(Schema); + modelBuilder.ApplyConfigurationsFromAssembly(typeof(TasksDbContext).Assembly); + } +} diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj new file mode 100644 index 0000000..3f2e19c --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TaskFlow.Tasks.Infrastructure.csproj @@ -0,0 +1,16 @@ + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + diff --git a/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs new file mode 100644 index 0000000..da717c6 --- /dev/null +++ b/src/Services/Tasks/TaskFlow.Tasks.Infrastructure/TasksModule.cs @@ -0,0 +1,39 @@ +using Microsoft.AspNetCore.Routing; +using Microsoft.EntityFrameworkCore; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; +using TaskFlow.Tasks.Application; +using TaskFlow.Tasks.Application.Abstractions; +using TaskFlow.Tasks.Infrastructure.Persistence; + +namespace TaskFlow.Tasks.Infrastructure; + +/// Composition du service Tasks. +public static class TasksModule +{ + /// Base propre au service Tasks, déclarée dans l'AppHost (AddDatabase("tasksdb")). + public const string DatabaseName = "tasksdb"; + + public static IHostApplicationBuilder AddTasksModule(this IHostApplicationBuilder builder) + { + builder.Services.AddTasksApplication(); + + builder.AddNpgsqlDbContext(DatabaseName); + + builder.Services.AddScoped(); + builder.Services.AddSingleton(TimeProvider.System); + + return builder; + } + + public static IEndpointRouteBuilder MapTasksModule(this IEndpointRouteBuilder app) => + app.MapTasksEndpoints(); + + /// Applique les migrations au démarrage (développement uniquement). + public static async Task MigrateTasksDatabaseAsync(this IServiceProvider services) + { + await using var scope = services.CreateAsyncScope(); + var db = scope.ServiceProvider.GetRequiredService(); + await db.Database.MigrateAsync(); + } +} diff --git a/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs b/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs index df36710..d3e7df3 100644 --- a/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs +++ b/tests/TaskFlow.ArchitectureTests/MicroserviceBoundaryTests.cs @@ -12,6 +12,12 @@ public class MicroserviceBoundaryTests private static readonly Assembly Gateway = Assembly.Load("TaskFlow.Gateway"); private static readonly Assembly ProjectsContracts = Assembly.Load("TaskFlow.Projects.Contracts"); + private static readonly string[] ProjectsAssemblies = + ["TaskFlow.Projects.Api", "TaskFlow.Projects.Application", "TaskFlow.Projects.Domain", "TaskFlow.Projects.Infrastructure"]; + + private static readonly string[] TasksAssemblies = + ["TaskFlow.Tasks.Api", "TaskFlow.Tasks.Application", "TaskFlow.Tasks.Domain", "TaskFlow.Tasks.Infrastructure"]; + private static IEnumerable TaskFlowReferences(Assembly assembly) => assembly.GetReferencedAssemblies() .Select(a => a.Name!) @@ -33,4 +39,28 @@ public void Les_Contracts_ne_dependent_d_aucun_autre_projet_TaskFlow() // Un contrat public doit pouvoir être référencé par n'importe quel service sans rien entraîner. TaskFlowReferences(ProjectsContracts).ShouldBeEmpty(); } + + [Fact] + public void Tasks_ne_connait_de_Projects_que_son_contrat() + { + foreach (var name in TasksAssemblies) + { + var forbidden = TaskFlowReferences(Assembly.Load(name)) + .Where(r => r.StartsWith("TaskFlow.Projects.", StringComparison.Ordinal) && r != "TaskFlow.Projects.Contracts") + .ToList(); + + forbidden.ShouldBeEmpty($"{name} référence : {string.Join(", ", forbidden)}"); + } + } + + [Fact] + public void Projects_ne_connait_pas_Tasks() + { + foreach (var name in ProjectsAssemblies) + { + TaskFlowReferences(Assembly.Load(name)) + .Where(r => r.StartsWith("TaskFlow.Tasks.", StringComparison.Ordinal)) + .ShouldBeEmpty($"{name} ne doit pas connaître le service Tasks"); + } + } } diff --git a/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj b/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj index 470f029..8d0ab10 100644 --- a/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj +++ b/tests/TaskFlow.ArchitectureTests/TaskFlow.ArchitectureTests.csproj @@ -12,6 +12,7 @@ + diff --git a/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs b/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs new file mode 100644 index 0000000..ab97400 --- /dev/null +++ b/tests/TaskFlow.ArchitectureTests/TasksLayerDependencyTests.cs @@ -0,0 +1,38 @@ +using System.Reflection; +using NetArchTest.Rules; +using Shouldly; + +namespace TaskFlow.ArchitectureTests; + +/// Même règle de dépendance que pour Projects, appliquée au service Tasks. +public class TasksLayerDependencyTests +{ + private static readonly Assembly TasksDomain = Assembly.Load("TaskFlow.Tasks.Domain"); + private static readonly Assembly TasksApplication = Assembly.Load("TaskFlow.Tasks.Application"); + + [Fact] + public void Domain_ne_depend_ni_d_EF_Core_ni_d_ASP_NET_ni_d_un_autre_service() + { + var result = Types.InAssembly(TasksDomain) + .ShouldNot().HaveDependencyOnAny( + "Microsoft.EntityFrameworkCore", + "Microsoft.AspNetCore", + "TaskFlow.Tasks.Application", + "TaskFlow.Tasks.Infrastructure", + "TaskFlow.Projects") + .GetResult(); + + result.IsSuccessful.ShouldBeTrue(LayerDependencyTests.Describe(result)); + } + + [Fact] + public void Application_ne_depend_ni_d_EF_Core_ni_de_Wolverine() + { + // Les handlers d'événements restent de simples classes : Wolverine les découvre par convention. + var result = Types.InAssembly(TasksApplication) + .ShouldNot().HaveDependencyOnAny("Microsoft.EntityFrameworkCore", "Wolverine", "TaskFlow.Tasks.Infrastructure") + .GetResult(); + + result.IsSuccessful.ShouldBeTrue(LayerDependencyTests.Describe(result)); + } +} diff --git a/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs b/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs new file mode 100644 index 0000000..320e3e3 --- /dev/null +++ b/tests/TaskFlow.Projects.UnitTests/ProjectTests.cs @@ -0,0 +1,43 @@ +using Shouldly; +using TaskFlow.Projects.Domain; + +namespace TaskFlow.Projects.UnitTests; + +public class ProjectTests +{ + private static readonly DateTimeOffset Now = new(2026, 9, 29, 12, 0, 0, TimeSpan.Zero); + + [Fact] + public void Create_avec_un_nom_valide_cree_le_projet_et_leve_ProjectCreatedDomainEvent() + { + var result = Project.Create(" Refonte du site ", Now); + + result.IsSuccess.ShouldBeTrue(); + var project = result.Value; + project.Name.ShouldBe("Refonte du site"); // espaces retirés + project.CreatedAt.ShouldBe(Now); + project.Id.Value.ShouldNotBe(Guid.Empty); + + var domainEvent = project.DomainEvents.ShouldHaveSingleItem().ShouldBeOfType(); + domainEvent.ProjectId.ShouldBe(project.Id); + } + + [Theory] + [InlineData("")] + [InlineData(" ")] + public void Create_sans_nom_echoue_avec_NameRequired(string name) + { + var result = Project.Create(name, Now); + + result.IsFailure.ShouldBeTrue(); + result.Error.ShouldBe(ProjectErrors.NameRequired); + } + + [Fact] + public void Create_avec_un_nom_trop_long_echoue_avec_NameTooLong() + { + var result = Project.Create(new string('x', Project.NameMaxLength + 1), Now); + + result.Error.ShouldBe(ProjectErrors.NameTooLong); + } +} diff --git a/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs b/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs new file mode 100644 index 0000000..de891f3 --- /dev/null +++ b/tests/TaskFlow.Tasks.UnitTests/ProjectCreatedHandlerTests.cs @@ -0,0 +1,57 @@ +using Microsoft.Extensions.Logging.Abstractions; +using Shouldly; +using TaskFlow.Projects.Contracts; +using TaskFlow.Tasks.Application.Abstractions; +using TaskFlow.Tasks.Application.IntegrationEvents; +using TaskFlow.Tasks.Domain; + +namespace TaskFlow.Tasks.UnitTests; + +public class ProjectCreatedHandlerTests +{ + private readonly InMemoryBoardRepository _boards = new(); + private readonly ProjectCreatedHandler _handler; + + public ProjectCreatedHandlerTests() => + _handler = new ProjectCreatedHandler(_boards, TimeProvider.System, NullLogger.Instance); + + [Fact] + public async Task Cree_le_board_du_projet_avec_les_colonnes_par_defaut() + { + var message = new ProjectCreated(Guid.NewGuid(), "Refonte du site", DateTimeOffset.UtcNow); + + await _handler.Handle(message, TestContext.Current.CancellationToken); + + var board = _boards.Items.ShouldHaveSingleItem(); + board.ProjectId.ShouldBe(message.ProjectId); + board.ProjectName.ShouldBe("Refonte du site"); + board.Columns.ShouldBe(Board.DefaultColumns); + } + + [Fact] + public async Task Est_idempotent_un_message_recu_deux_fois_ne_cree_qu_un_board() + { + var message = new ProjectCreated(Guid.NewGuid(), "Refonte du site", DateTimeOffset.UtcNow); + + await _handler.Handle(message, TestContext.Current.CancellationToken); + await _handler.Handle(message, TestContext.Current.CancellationToken); // redistribution RabbitMQ + + _boards.Items.Count.ShouldBe(1); + } + + /// Faux dépôt en mémoire : teste la logique du handler sans base de données. + private sealed class InMemoryBoardRepository : IBoardRepository + { + public List Items { get; } = []; + + public Task ExistsForProjectAsync(Guid projectId, CancellationToken ct) => + Task.FromResult(Items.Any(b => b.ProjectId == projectId)); + + public void Add(Board board) => Items.Add(board); + + public Task> ListAsync(CancellationToken ct) => + Task.FromResult>(Items); + + public Task SaveChangesAsync(CancellationToken ct) => Task.CompletedTask; + } +} diff --git a/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj b/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj new file mode 100644 index 0000000..1d10a64 --- /dev/null +++ b/tests/TaskFlow.Tasks.UnitTests/TaskFlow.Tasks.UnitTests.csproj @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + +