Add endpoints to update display order for monitoring, citizen, and in…

api/src/Feature.Forms/Specifications/GetCitizenReportingFormsByIdsSpecification.cs

@@ -0,0 +1,15 @@
+using Vote.Monitor.Domain.Entities.FormBase;
+
+namespace Feature.Forms.Specifications;
+
+public sealed class GetCitizenReportingFormsByIdsSpecification : Specification<FormAggregate>
+{
+    public GetCitizenReportingFormsByIdsSpecification(Guid electionRoundId, Guid ngoId, IEnumerable<Guid> formIds)
+    {
+        Query.Where(x =>
+            x.ElectionRoundId == electionRoundId
+            && x.MonitoringNgo.NgoId == ngoId
+            && x.FormType == FormType.CitizenReporting
+            && formIds.Contains(x.Id));
+    }
+}

api/src/Feature.Forms/Specifications/GetFormsByIdsSpecification.cs

@@ -0,0 +1,16 @@
+using Vote.Monitor.Domain.Entities.FormBase;
+
+namespace Feature.Forms.Specifications;
+
+public sealed class GetFormsByIdsSpecification : Specification<FormAggregate>
+{
+    public GetFormsByIdsSpecification(Guid electionRoundId, Guid ngoId, IEnumerable<Guid> formIds)
+    {
+        Query.Where(x =>
+            x.ElectionRoundId == electionRoundId
+            && x.MonitoringNgo.NgoId == ngoId
+            && x.FormType != FormType.CitizenReporting
+            && x.FormType != FormType.IncidentReporting
+            && formIds.Contains(x.Id));
+    }
+}

api/src/Feature.Forms/Specifications/GetIncidentReportingFormsByIdsSpecification.cs

@@ -0,0 +1,15 @@
+using Vote.Monitor.Domain.Entities.FormBase;
+
+namespace Feature.Forms.Specifications;
+
+public sealed class GetIncidentReportingFormsByIdsSpecification : Specification<FormAggregate>
+{
+    public GetIncidentReportingFormsByIdsSpecification(Guid electionRoundId, Guid ngoId, IEnumerable<Guid> formIds)
+    {
+        Query.Where(x =>
+            x.ElectionRoundId == electionRoundId
+            && x.MonitoringNgo.NgoId == ngoId
+            && x.FormType == FormType.IncidentReporting
+            && formIds.Contains(x.Id));
+    }
+}

api/src/Feature.Forms/UpdateCitizenReportingDisplayOrder/Endpoint.cs

@@ -0,0 +1,69 @@
+using Authorization.Policies;
+using Authorization.Policies.Requirements;
+using Feature.Forms.Specifications;
+using Microsoft.AspNetCore.Authorization;
+using Vote.Monitor.Domain.Entities.FormAggregate;
+using Vote.Monitor.Domain.Entities.MonitoringNgoAggregate;
+
+namespace Feature.Forms.UpdateCitizenReportingDisplayOrder;
+
+public class Endpoint(
+    IAuthorizationService authorizationService,
+    IRepository<MonitoringNgo> monitoringNgoRepository,
+    IRepository<FormAggregate> formsRepository) : Endpoint<Request, Results<NoContent, NotFound, ProblemDetails>>
+{
+    public override void Configure()
+    {
+        Put("/api/election-rounds/{electionRoundId}/citizen-reporting-forms:display-order");
+        Description(x => x.Accepts<Request>());
+        DontAutoTag();
+        Options(x => x.WithTags("citizen-reporting-forms", "forms"));
+        Policies(PolicyNames.NgoAdminsOnly);
+        Summary(s =>
+        {
+            s.Summary =
+                "Updates display order for published citizen reporting forms belonging to the citizen reporting monitoring NGO";
+        });
+    }
+
+    public override async Task<Results<NoContent, NotFound, ProblemDetails>> ExecuteAsync(Request req,
+        CancellationToken ct)
+    {
+        var requirement = new CitizenReportingNgoAdminRequirement(req.ElectionRoundId);
+        var authorizationResult = await authorizationService.AuthorizeAsync(User, requirement);
+        if (!authorizationResult.Succeeded)
+        {
+            return TypedResults.NotFound();
+        }
+
+        var formIds = req.Forms.Select(x => x.FormId).ToList();
+        var forms = await formsRepository.ListAsync(
+            new GetCitizenReportingFormsByIdsSpecification(req.ElectionRoundId, req.NgoId, formIds), ct);
+
+        if (forms.Count != formIds.Count)
+        {
+            return TypedResults.NotFound();
+        }
+
+        if (forms.Any(x => x.Status != FormStatus.Published))
+        {
+            AddError("All forms must be published.");
+            return new ProblemDetails(ValidationFailures);
+        }
+
+        var displayOrders = req.Forms.ToDictionary(x => x.FormId, x => x.DisplayOrder);
+        foreach (var form in forms)
+        {
+            form.UpdateDisplayOrder(displayOrders[form.Id]);
+        }
+
+        await formsRepository.UpdateRangeAsync(forms, ct);
+
+        var monitoringNgo = await monitoringNgoRepository.FirstOrDefaultAsync(
+            new GetMonitoringNgoSpecification(req.ElectionRoundId, req.NgoId), ct);
+        monitoringNgo!.UpdateFormVersion();
+        await monitoringNgoRepository.UpdateAsync(monitoringNgo, ct);
+
+        return TypedResults.NoContent();
+    }
+}

api/src/Feature.Forms/UpdateCitizenReportingDisplayOrder/Request.cs

@@ -0,0 +1,19 @@
+using Vote.Monitor.Core.Security;
+
+namespace Feature.Forms.UpdateCitizenReportingDisplayOrder;
+
+public class Request
+{
+    public Guid ElectionRoundId { get; set; }
+
+    [FromClaim(ApplicationClaimTypes.NgoId)]
+    public Guid NgoId { get; set; }
+
+    public List<FormDisplayOrderModel> Forms { get; set; } = [];
+}
+
+public class FormDisplayOrderModel
+{
+    public Guid FormId { get; set; }
+    public int DisplayOrder { get; set; }
+}

api/src/Feature.Forms/UpdateCitizenReportingDisplayOrder/Validator.cs

@@ -0,0 +1,20 @@
+namespace Feature.Forms.UpdateCitizenReportingDisplayOrder;
+
+public class Validator : Validator<Request>
+{
+    public Validator()
+    {
+        RuleFor(x => x.ElectionRoundId).NotEmpty();
+        RuleFor(x => x.NgoId).NotEmpty();
+        RuleFor(x => x.Forms).NotEmpty();
+        RuleFor(x => x.Forms)
+            .Must(forms => forms.Select(f => f.FormId).Distinct().Count() == forms.Count)
+            .WithMessage("Form ids must be unique.");
+
+        RuleForEach(x => x.Forms).ChildRules(form =>
+        {
+            form.RuleFor(x => x.FormId).NotEmpty();
+            form.RuleFor(x => x.DisplayOrder).GreaterThanOrEqualTo(0);
+        });
+    }
+}

api/src/Feature.Forms/UpdateDisplayOrder/Endpoint.cs

@@ -0,0 +1,68 @@
+using Authorization.Policies;
+using Authorization.Policies.Requirements;
+using Feature.Forms.Specifications;
+using Microsoft.AspNetCore.Authorization;
+using Vote.Monitor.Domain.Entities.FormAggregate;
+using Vote.Monitor.Domain.Entities.MonitoringNgoAggregate;
+
+namespace Feature.Forms.UpdateDisplayOrder;
+
+public class Endpoint(
+    IAuthorizationService authorizationService,
+    IRepository<MonitoringNgo> monitoringNgoRepository,
+    IRepository<FormAggregate> formsRepository) : Endpoint<Request, Results<NoContent, NotFound, ProblemDetails>>
+{
+    public override void Configure()
+    {
+        Put("/api/election-rounds/{electionRoundId}/forms:display-order");
+        Description(x => x.Accepts<Request>());
+        DontAutoTag();
+        Options(x => x.WithTags("forms"));
+        Policies(PolicyNames.NgoAdminsOnly);
+        Summary(s =>
+        {
+            s.Summary = "Updates display order for published forms belonging to the current monitoring NGO";
+        });
+    }
+
+    public override async Task<Results<NoContent, NotFound, ProblemDetails>> ExecuteAsync(Request req,
+        CancellationToken ct)
+    {
+        var requirement = new MonitoringNgoAdminRequirement(req.ElectionRoundId);
+        var authorizationResult = await authorizationService.AuthorizeAsync(User, requirement);
+        if (!authorizationResult.Succeeded)
+        {
+            return TypedResults.NotFound();
+        }
+
+        var formIds = req.Forms.Select(x => x.FormId).ToList();
+        var forms = await formsRepository.ListAsync(
+            new GetFormsByIdsSpecification(req.ElectionRoundId, req.NgoId, formIds), ct);
+
+        if (forms.Count != formIds.Count)
+        {
+            return TypedResults.NotFound();
+        }
+
+        if (forms.Any(x => x.Status != FormStatus.Published))
+        {
+            AddError("All forms must be published.");
+            return new ProblemDetails(ValidationFailures);
+        }
+
+        var displayOrders = req.Forms.ToDictionary(x => x.FormId, x => x.DisplayOrder);
+        foreach (var form in forms)
+        {
+            form.UpdateDisplayOrder(displayOrders[form.Id]);
+        }
+
+        await formsRepository.UpdateRangeAsync(forms, ct);
+
+        var monitoringNgo = await monitoringNgoRepository.FirstOrDefaultAsync(
+            new GetMonitoringNgoSpecification(req.ElectionRoundId, req.NgoId), ct);
+        monitoringNgo!.UpdateFormVersion();
+        await monitoringNgoRepository.UpdateAsync(monitoringNgo, ct);
+
+        return TypedResults.NoContent();
+    }
+}

api/src/Feature.Forms/UpdateDisplayOrder/Request.cs

@@ -0,0 +1,19 @@
+using Vote.Monitor.Core.Security;
+
+namespace Feature.Forms.UpdateDisplayOrder;
+
+public class Request
+{
+    public Guid ElectionRoundId { get; set; }
+
+    [FromClaim(ApplicationClaimTypes.NgoId)]
+    public Guid NgoId { get; set; }
+
+    public List<FormDisplayOrderModel> Forms { get; set; } = [];
+}
+
+public class FormDisplayOrderModel
+{
+    public Guid FormId { get; set; }
+    public int DisplayOrder { get; set; }
+}

api/src/Feature.Forms/UpdateDisplayOrder/Validator.cs

@@ -0,0 +1,20 @@
+namespace Feature.Forms.UpdateDisplayOrder;
+
+public class Validator : Validator<Request>
+{
+    public Validator()
+    {
+        RuleFor(x => x.ElectionRoundId).NotEmpty();
+        RuleFor(x => x.NgoId).NotEmpty();
+        RuleFor(x => x.Forms).NotEmpty();
+        RuleFor(x => x.Forms)
+            .Must(forms => forms.Select(f => f.FormId).Distinct().Count() == forms.Count)
+            .WithMessage("Form ids must be unique.");
+
+        RuleForEach(x => x.Forms).ChildRules(form =>
+        {
+            form.RuleFor(x => x.FormId).NotEmpty();
+            form.RuleFor(x => x.DisplayOrder).GreaterThanOrEqualTo(0);
+        });
+    }
+}

api/src/Feature.Forms/UpdateIncidentReportingDisplayOrder/Endpoint.cs

@@ -0,0 +1,69 @@
+using Authorization.Policies;
+using Authorization.Policies.Requirements;
+using Feature.Forms.Specifications;
+using Microsoft.AspNetCore.Authorization;
+using Vote.Monitor.Domain.Entities.FormAggregate;
+using Vote.Monitor.Domain.Entities.MonitoringNgoAggregate;
+
+namespace Feature.Forms.UpdateIncidentReportingDisplayOrder;
+
+public class Endpoint(
+    IAuthorizationService authorizationService,
+    IRepository<MonitoringNgo> monitoringNgoRepository,
+    IRepository<FormAggregate> formsRepository) : Endpoint<Request, Results<NoContent, NotFound, ProblemDetails>>
+{
+    public override void Configure()
+    {
+        Put("/api/election-rounds/{electionRoundId}/incident-reporting-forms:display-order");
+        Description(x => x.Accepts<Request>());
+        DontAutoTag();
+        Options(x => x.WithTags("incident-reporting-forms", "forms"));
+        Policies(PolicyNames.NgoAdminsOnly);
+        Summary(s =>
+        {
+            s.Summary =
+                "Updates display order for published incident reporting forms belonging to the current monitoring NGO";
+        });
+    }
+
+    public override async Task<Results<NoContent, NotFound, ProblemDetails>> ExecuteAsync(Request req,
+        CancellationToken ct)
+    {
+        var requirement = new MonitoringNgoAdminRequirement(req.ElectionRoundId);
+        var authorizationResult = await authorizationService.AuthorizeAsync(User, requirement);
+        if (!authorizationResult.Succeeded)
+        {
+            return TypedResults.NotFound();
+        }
+
+        var formIds = req.Forms.Select(x => x.FormId).ToList();
+        var forms = await formsRepository.ListAsync(
+            new GetIncidentReportingFormsByIdsSpecification(req.ElectionRoundId, req.NgoId, formIds), ct);
+
+        if (forms.Count != formIds.Count)
+        {
+            return TypedResults.NotFound();
+        }
+
+        if (forms.Any(x => x.Status != FormStatus.Published))
+        {
+            AddError("All forms must be published.");
+            return new ProblemDetails(ValidationFailures);
+        }
+
+        var displayOrders = req.Forms.ToDictionary(x => x.FormId, x => x.DisplayOrder);
+        foreach (var form in forms)
+        {
+            form.UpdateDisplayOrder(displayOrders[form.Id]);
+        }
+
+        await formsRepository.UpdateRangeAsync(forms, ct);
+
+        var monitoringNgo = await monitoringNgoRepository.FirstOrDefaultAsync(
+            new GetMonitoringNgoSpecification(req.ElectionRoundId, req.NgoId), ct);
+        monitoringNgo!.UpdateFormVersion();
+        await monitoringNgoRepository.UpdateAsync(monitoringNgo, ct);
+
+        return TypedResults.NoContent();
+    }
+}

api/src/Feature.Forms/UpdateIncidentReportingDisplayOrder/Request.cs

@@ -0,0 +1,19 @@
+using Vote.Monitor.Core.Security;
+
+namespace Feature.Forms.UpdateIncidentReportingDisplayOrder;
+
+public class Request
+{
+    public Guid ElectionRoundId { get; set; }
+
+    [FromClaim(ApplicationClaimTypes.NgoId)]
+    public Guid NgoId { get; set; }
+
+    public List<FormDisplayOrderModel> Forms { get; set; } = [];
+}
+
+public class FormDisplayOrderModel
+{
+    public Guid FormId { get; set; }
+    public int DisplayOrder { get; set; }
+}

api/src/Feature.Forms/UpdateIncidentReportingDisplayOrder/Validator.cs

@@ -0,0 +1,20 @@
+namespace Feature.Forms.UpdateIncidentReportingDisplayOrder;
+
+public class Validator : Validator<Request>
+{
+    public Validator()
+    {
+        RuleFor(x => x.ElectionRoundId).NotEmpty();
+        RuleFor(x => x.NgoId).NotEmpty();
+        RuleFor(x => x.Forms).NotEmpty();
+        RuleFor(x => x.Forms)
+            .Must(forms => forms.Select(f => f.FormId).Distinct().Count() == forms.Count)
+            .WithMessage("Form ids must be unique.");
+
+        RuleForEach(x => x.Forms).ChildRules(form =>
+        {
+            form.RuleFor(x => x.FormId).NotEmpty();
+            form.RuleFor(x => x.DisplayOrder).GreaterThanOrEqualTo(0);
+        });
+    }
+}

api/src/Vote.Monitor.Domain/Entities/FormAggregate/Form.cs

@@ -23,6 +23,11 @@ public class Form : BaseForm
     public ElectionRound ElectionRound { get; private set; }
     public int DisplayOrder { get; private set; }
 
+    public void UpdateDisplayOrder(int displayOrder)
+    {
+        DisplayOrder = displayOrder;
+    }
+
     private Form(
         ElectionRound electionRound,
         MonitoringNgo monitoringNgo,