Feat/ElectionRoundFormTemplatesAssignment (#870)

* adding ElectionRoundFormTemplate #1

Creating entity and starting endpoint

* Update .gitignore

ignoring /api/src/Vote.Monitor.Api/Uploads

* assign templates to election round - endpoint#1

assign templates to election round - endpoint with tests #1

* adding AssignTemplates tests for DeleteRangeAsync and Validator  #2

* adjust for ElectionRoundFormTemplateAssignment #3

updates on assigning templates on an ElectionRound consisting of tests, endpoint and configuration files

* adjust testValidators  ElectionRoundFormTemplateAssignment #4

---------

Co-authored-by: Ion Dormenco <idormenco@gmail.com>

Author: FriptuT

.gitignore

@@ -271,3 +271,4 @@ log*.txt
 .vscode
 
 OfflineCapabilities
+/api/src/Vote.Monitor.Api/Uploads

api/src/Feature.FormTemplates/AssignTemplates/Endpoint.cs

@@ -0,0 +1,66 @@
+using Feature.FormTemplates.Specifications;
+using Microsoft.EntityFrameworkCore;
+using Vote.Monitor.Domain;
+using Vote.Monitor.Domain.Entities.ElectionRoundAggregate;
+using Vote.Monitor.Domain.Entities.ElectionRoundFormTemplateAggregate;
+
+namespace Feature.FormTemplates.AssignTemplates;
+
+public class Endpoint(
+    IReadRepository<ElectionRound> electionRoundRepository,
+    IReadRepository<FormTemplateAggregate> formTemplateRepository,
+    IRepository<ElectionRoundFormTemplate> electionRoundFormTemplateRepository
+) :
+    Endpoint<Request, Results<NoContent, NotFound>>
+{
+    public override void Configure()
+    {
+        Post("/api/election-rounds/{electionRoundId}/form-templates:assign-templates");
+        Policies(PolicyNames.PlatformAdminsOnly);
+    }
+
+    public override async Task<Results<NoContent, NotFound>> ExecuteAsync(Request req, CancellationToken ct)
+    {
+        var electionRoundExists =
+            await electionRoundRepository.AnyAsync(new GetElectionRoundByIdSpecification(req.ElectionRoundId), ct);
+
+        if (electionRoundExists is false)
+        {
+            return TypedResults.NotFound();
+        }
+
+        if (await formTemplateRepository.CountAsync(new ListFormTemplatesByIds(req.FormTemplateIds)) !=
+            req.FormTemplateIds.Count)
+        {
+            return TypedResults.NotFound();
+        }
+
+        var existingAssignments = await electionRoundFormTemplateRepository
+            .ListAsync(new ListElectionRoundFormTemplateSpecification(req.ElectionRoundId), ct);
+
+        var existingTemplateIds = existingAssignments
+            .Select(x => x.FormTemplateId)
+            .ToList();
+
+        var templatesToAdd = req.FormTemplateIds.Except(existingTemplateIds).ToList();
+        var templatesToRemove = existingTemplateIds.Except(req.FormTemplateIds).ToList();
+
+        if (templatesToRemove.Any())
+        {
+            var assignmentsToDelete = existingAssignments
+                .Where(x => templatesToRemove.Contains(x.FormTemplateId))
+                .ToList();
+            await electionRoundFormTemplateRepository.DeleteRangeAsync(assignmentsToDelete, ct);
+        }
+
+        if (templatesToAdd.Any())
+        {
+            var newAssignments = templatesToAdd
+                .Select(templateId => ElectionRoundFormTemplate.Create(req.ElectionRoundId, templateId))
+                .ToList();
+            await electionRoundFormTemplateRepository.AddRangeAsync(newAssignments, ct);
+        }
+
+        return TypedResults.NoContent();
+    }
+}

api/src/Feature.FormTemplates/AssignTemplates/Request.cs

@@ -0,0 +1,7 @@
+namespace Feature.FormTemplates.AssignTemplates;
+
+public class Request
+{
+    public Guid ElectionRoundId { get; set; }
+    public List<Guid> FormTemplateIds { get; set; } = new List<Guid>();
+}

api/src/Feature.FormTemplates/AssignTemplates/Validator.cs

@@ -0,0 +1,11 @@
+namespace Feature.FormTemplates.AssignTemplates;
+
+public class Validator : Validator<Request>
+{
+    public Validator()
+    {
+        RuleFor(x => x.ElectionRoundId).NotEmpty();
+        RuleFor(x => x.FormTemplateIds).NotEmpty();
+        RuleForEach(x => x.FormTemplateIds).NotEmpty();
+    }
+}

api/src/Feature.FormTemplates/Specifications/GetElectionRoundByIdSpecification.cs

@@ -0,0 +1,11 @@
+using Vote.Monitor.Domain.Entities.ElectionRoundAggregate;
+
+namespace Feature.FormTemplates.Specifications;
+
+public sealed class GetElectionRoundByIdSpecification : Specification<ElectionRound>
+{
+    public GetElectionRoundByIdSpecification(Guid electionRoundId)
+    {
+        Query.Where(x => x.Id == electionRoundId);
+    }
+}

api/src/Feature.FormTemplates/Specifications/ListElectionRoundFormTemplateSpecification.cs

@@ -0,0 +1,11 @@
+using Vote.Monitor.Domain.Entities.ElectionRoundFormTemplateAggregate;
+
+namespace Feature.FormTemplates.Specifications;
+
+public sealed class ListElectionRoundFormTemplateSpecification : Specification<ElectionRoundFormTemplate>
+{
+    public ListElectionRoundFormTemplateSpecification(Guid electionRoundId)
+    {
+        Query.Where(e => e.ElectionRoundId == electionRoundId);
+    }
+}

api/src/Feature.FormTemplates/Specifications/ListFormTemplatesByIds.cs

@@ -0,0 +1,9 @@
+namespace Feature.FormTemplates.Specifications;
+
+public sealed class ListFormTemplatesByIds: Specification<FormTemplateAggregate>
+{
+    public ListFormTemplatesByIds(List<Guid> formTemplateIds)
+    {
+        Query.Where(formTemplate => formTemplateIds.Contains(formTemplate.Id));
+    }
+}

api/src/Vote.Monitor.Domain/Entities/ElectionRoundFormTemplateAggregate/ElectionRoundFormTemplate.cs

@@ -0,0 +1,29 @@
+using Vote.Monitor.Domain.Entities.FormTemplateAggregate;
+
+namespace Vote.Monitor.Domain.Entities.ElectionRoundFormTemplateAggregate;
+
+public class ElectionRoundFormTemplate: AuditableBaseEntity, IAggregateRoot
+{
+    public Guid Id { get; private set; }
+    public Guid ElectionRoundId { get;  private set; }
+    public ElectionRound ElectionRound { get; private set; }
+    public Guid FormTemplateId { get; private set; }
+    public FormTemplate FormTemplate { get; private set; }
+
+    internal ElectionRoundFormTemplate(Guid electionRoundId, Guid formTemplateId)
+    {
+        Id = Guid.NewGuid();
+        ElectionRoundId = electionRoundId;
+        FormTemplateId = formTemplateId;
+    }
+
+    public static ElectionRoundFormTemplate Create(Guid electionRoundId, Guid formTemplateId) =>
+        new(electionRoundId, formTemplateId);
+    
+#pragma warning disable CS8618 // Required by Entity Framework
+    private ElectionRoundFormTemplate()
+    {
+
+    }
+#pragma warning restore CS8618
+}

api/src/Vote.Monitor.Domain/EntitiesConfiguration/ElectionRoundFormTemplateConfiguration.cs

@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Vote.Monitor.Domain.Entities.ElectionRoundFormTemplateAggregate;
+
+namespace Vote.Monitor.Domain.EntitiesConfiguration;
+
+public class ElectionRoundFormTemplateConfiguration : IEntityTypeConfiguration<ElectionRoundFormTemplate>
+{
+    public void Configure(EntityTypeBuilder<ElectionRoundFormTemplate> builder)
+    {
+        builder.HasKey(x => x.Id);
+
+        builder.HasIndex(x => new { x.ElectionRoundId, x.FormTemplateId }).IsUnique();
+
+        builder
+            .HasOne(x => x.ElectionRound)
+            .WithMany()
+            .HasForeignKey(x => x.ElectionRoundId);
+
+        builder.HasOne(x => x.FormTemplate)
+            .WithMany()
+            .HasForeignKey(x => x.FormTemplateId);
+    }
+}