Merge pull request #39 from OS2Valghalla/dev

Merge branch 'Dev'
OS2Valghalla · Apr 29, 2024 · 96c9e3d · 96c9e3d
2 parents 48a053c + 1f124c2
commit 96c9e3d
Show file tree

Hide file tree

Showing 18 changed files with 143 additions and 51 deletions.
diff --git a/Valghalla.Application/TaskValidation/EvaluatedParticipant.cs b/Valghalla.Application/TaskValidation/EvaluatedParticipant.cs
@@ -3,7 +3,7 @@
     public sealed record EvaluatedParticipant
     {
         public Guid Id { get; init; }
-        public int Age { get; init; }
+        public DateTime Birthdate { get; init; }
         public string? MunicipalityCode { get; set; }
         public string? CountryCode { get; set; }
         public bool Deceased { get; init; }

diff --git a/Valghalla.Application/TaskValidation/EvaluatedTask.cs b/Valghalla.Application/TaskValidation/EvaluatedTask.cs
@@ -0,0 +1,10 @@
+namespace Valghalla.Application.TaskValidation
+{
+    public sealed record EvaluatedTask
+    {
+        public Guid TaskAssignmentId { get; init; }
+        public Guid TaskTypeId { get; init; }
+        public DateTime TaskDate { get; init; }
+        public bool ValidationNotRequired { get; init; }
+    }
+}
diff --git a/Valghalla.Application/TaskValidation/ITaskValidationRepository.cs b/Valghalla.Application/TaskValidation/ITaskValidationRepository.cs
@@ -3,8 +3,7 @@
     public interface ITaskValidationRepository
     {
         Task<IEnumerable<TaskValidationRule>> GetValidationRules(Guid electionId, CancellationToken cancellationToken);
-        Task<EvaluatedTaskType> GetEvaluatedTaskType(Guid taskTypeId, CancellationToken cancellationToken);
-        Task<EvaluatedTaskType> GetEvaluatedTaskTypeByTaskId(Guid taskId, CancellationToken cancellationToken);
+        Task<EvaluatedTask> GetEvaluatedTask(Guid taskAssignmentId, CancellationToken cancellationToken);
         Task<EvaluatedParticipant> GetEvaluatedParticipant(Guid participantId, CancellationToken cancellationToken);
     }
 }
diff --git a/Valghalla.Application/TaskValidation/ITaskValidationService.cs b/Valghalla.Application/TaskValidation/ITaskValidationService.cs
@@ -2,8 +2,8 @@
 {
     public interface ITaskValidationService
     {
-        TaskValidationResult Execute(EvaluatedTaskType taskType, EvaluatedParticipant participant, IEnumerable<TaskValidationRule> rules);
-        Task<TaskValidationResult> ExecuteAsync(Guid taskTypeId, Guid electionId, Guid participantId, CancellationToken cancellationToken);
-        Task<TaskValidationResult> ExecuteAsync(Guid taskTypeId, Guid electionId, string cpr, CancellationToken cancellationToken);
+        TaskValidationResult Execute(EvaluatedTask taskAssignment, EvaluatedParticipant participant, IEnumerable<TaskValidationRule> rules);
+        Task<TaskValidationResult> ExecuteAsync(Guid taskAssignmentId, Guid electionId, Guid participantId, CancellationToken cancellationToken);
+        Task<TaskValidationResult> ExecuteAsync(Guid taskAssignmentId, Guid electionId, string cpr, CancellationToken cancellationToken);
     }
 }
diff --git a/Valghalla.Application/TaskValidation/TaskValidationService.cs b/Valghalla.Application/TaskValidation/TaskValidationService.cs
@@ -16,7 +16,7 @@ public TaskValidationService(ITaskValidationRepository taskValidationRepository,
             this.cprService = cprService;
         }
 
-        public TaskValidationResult Execute(EvaluatedTaskType taskType, EvaluatedParticipant participant, IEnumerable<TaskValidationRule> rules)
+        public TaskValidationResult Execute(EvaluatedTask taskAssignment, EvaluatedParticipant participant, IEnumerable<TaskValidationRule> rules)
         {
             var failedRules = new List<TaskValidationRule>();
 
@@ -25,14 +25,19 @@ public TaskValidationResult Execute(EvaluatedTaskType taskType, EvaluatedPartici
                 failedRules.Add(TaskValidationRule.Alive);
             }
 
-            if (taskType.ValidationNotRequired)
+            if (taskAssignment.ValidationNotRequired)
             {
                 return new(failedRules);
             }
 
-            if (rules.Any(i => i.Id == TaskValidationRule.Age18.Id) && participant.Age < 18)
+            if (rules.Any(i => i.Id == TaskValidationRule.Age18.Id))
             {
-                failedRules.Add(TaskValidationRule.Age18);
+                var age = CalculateAge(participant, taskAssignment);
+
+                if (age < 18)
+                {
+                    failedRules.Add(TaskValidationRule.Age18);
+                }
             }
 
             if (rules.Any(i => i.Id == TaskValidationRule.Disenfranchised.Id) && participant.Disenfranchised)
@@ -53,25 +58,25 @@ public TaskValidationResult Execute(EvaluatedTaskType taskType, EvaluatedPartici
             return new(failedRules);
         }
 
-        public async Task<TaskValidationResult> ExecuteAsync(Guid taskTypeId, Guid electionId, Guid participantId, CancellationToken cancellationToken)
+        public async Task<TaskValidationResult> ExecuteAsync(Guid taskAssignmentId, Guid electionId, Guid participantId, CancellationToken cancellationToken)
         {
-            var taskType = await taskValidationRepository.GetEvaluatedTaskType(taskTypeId, cancellationToken);
+            var taskType = await taskValidationRepository.GetEvaluatedTask(taskAssignmentId, cancellationToken);
             var participant = await taskValidationRepository.GetEvaluatedParticipant(participantId, cancellationToken);
             var rules = await taskValidationRepository.GetValidationRules(electionId, cancellationToken);
 
             return Execute(taskType, participant, rules);
         }
 
-        public async Task<TaskValidationResult> ExecuteAsync(Guid taskId, Guid electionId, string cpr, CancellationToken cancellationToken)
+        public async Task<TaskValidationResult> ExecuteAsync(Guid taskAssignmentId, Guid electionId, string cpr, CancellationToken cancellationToken)
         {
-            var taskType = await taskValidationRepository.GetEvaluatedTaskTypeByTaskId(taskId, cancellationToken);
+            var taskType = await taskValidationRepository.GetEvaluatedTask(taskAssignmentId, cancellationToken);
             var cprPersonInfo = await cprService.ExecuteAsync(cpr);
             var record = cprPersonInfo.ToRecord();
 
             var evaluatedParticipant = new EvaluatedParticipant()
             {
                 Id = Guid.Empty,
-                Age = record.Age,
+                Birthdate = record.Birthdate,
                 CountryCode = record.CountryCode,
                 Deceased = record.Deceased,
                 Disenfranchised = record.Disenfranchised,
@@ -82,5 +87,28 @@ public async Task<TaskValidationResult> ExecuteAsync(Guid taskId, Guid electionI
 
             return Execute(taskType, evaluatedParticipant, rules);
         }
+
+        private static int CalculateAge(EvaluatedParticipant participant, EvaluatedTask taskAssignment)
+        {
+            var taskDateLocalTime = taskAssignment.TaskDate.ToLocalTime();
+            var birthDateLocalTime = participant.Birthdate.ToLocalTime();
+            var taskDate = new DateTime(taskDateLocalTime.Year, taskDateLocalTime.Month, taskDateLocalTime.Day);
+            var birthdate = new DateTime(birthDateLocalTime.Year, birthDateLocalTime.Month, birthDateLocalTime.Day);
+
+            var months = taskDate.Month - birthdate.Month;
+            var years = taskDate.Year - birthdate.Year;
+
+            if (taskDate.Day < birthdate.Day)
+            {
+                months--;
+            }
+
+            if (months < 0)
+            {
+                years--;
+            }
+
+            return years;
+        }
     }
 }
diff --git a/Valghalla.External.Application/Modules/Tasks/Commands/AcceptTaskCommand.cs b/Valghalla.External.Application/Modules/Tasks/Commands/AcceptTaskCommand.cs
@@ -58,7 +58,7 @@ public async Task<Response> Handle(AcceptTaskCommand command, CancellationToken
                 return Response.Ok(TaskConfirmationResult.ConflictResult());
             }
 
-            var validationResult = await taskValidationService.ExecuteAsync(taskAssignment.TaskTypeId, taskAssignment.ElectionId, participantId, cancellationToken);
+            var validationResult = await taskValidationService.ExecuteAsync(taskAssignment.Id, taskAssignment.ElectionId, participantId, cancellationToken);
 
             if (!validationResult.Succeed)
             {

diff --git a/Valghalla.External.Web/package.json b/Valghalla.External.Web/package.json
@@ -4,7 +4,7 @@
   "scripts": {
     "ng": "ng",
     "start": "node --max-http-header-size=100000 ./serve",
-    "build": "ng build",
+    "build": "ng build --output-hashing=all",
     "watch": "ng build --watch --configuration development",
     "test": "ng test",
     "lint": "ng lint",

diff --git a/Valghalla.Infrastructure/TaskValidation/TaskValidationRepository.cs b/Valghalla.Infrastructure/TaskValidation/TaskValidationRepository.cs
@@ -44,26 +44,23 @@ public async Task<IEnumerable<TaskValidationRule>> GetValidationRules(Guid elect
             return entities.Select(i => new TaskValidationRule(i.ValidationRuleId)).ToArray();
         }
 
-        public async Task<EvaluatedTaskType> GetEvaluatedTaskType(Guid taskTypeId, CancellationToken cancellationToken)
-        {
-            var entity = await taskTypes
-                .Where(i => i.Id == taskTypeId)
-                .SingleAsync(cancellationToken);
-
-            return mapper.Map<EvaluatedTaskType>(entity);
-        }
-
-        public async Task<EvaluatedTaskType> GetEvaluatedTaskTypeByTaskId(Guid taskId, CancellationToken cancellationToken)
+        public async Task<EvaluatedTask> GetEvaluatedTask(Guid taskAssignmentId, CancellationToken cancellationToken)
         {
             var task = await tasks
-                .Where(i => i.Id == taskId)
+                .Where(i => i.Id == taskAssignmentId)
                 .SingleAsync(cancellationToken);
 
             var entity = await taskTypes
                 .Where(i => i.Id == task.TaskTypeId)
                 .SingleAsync(cancellationToken);
 
-            return mapper.Map<EvaluatedTaskType>(entity);
+            return new EvaluatedTask()
+            {
+                TaskAssignmentId = taskAssignmentId,
+                TaskTypeId = entity.Id,
+                TaskDate = task.TaskDate,
+                ValidationNotRequired = entity.ValidationNotRequired
+            };
         }
     }
 }
diff --git a/...a.Internal.Application.Tests/Tasks/Commands/AssignParticipantToTaskCommandHandlerTests.cs b/...a.Internal.Application.Tests/Tasks/Commands/AssignParticipantToTaskCommandHandlerTests.cs
@@ -66,7 +66,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { })));
 
             var result = validator.TestValidate(command);
@@ -92,7 +92,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { })));
 
             var result = validator.TestValidate(command);
@@ -118,7 +118,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { })));
 
             var result = validator.TestValidate(command);
@@ -144,7 +144,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { })));
 
             var result = validator.TestValidate(command);
@@ -172,7 +172,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { new TaskValidationRule(TaskValidationRule.Alive.Id) })));
 
             var result = validator.TestValidate(command);
@@ -202,7 +202,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { new TaskValidationRule(TaskValidationRule.Age18.Id) })));
 
             var result = validator.TestValidate(command);
@@ -232,7 +232,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { new TaskValidationRule(TaskValidationRule.ResidencyMunicipality.Id) })));
 
             var result = validator.TestValidate(command);
@@ -262,7 +262,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { new TaskValidationRule(TaskValidationRule.Disenfranchised.Id) })));
 
             var result = validator.TestValidate(command);
@@ -292,7 +292,7 @@ public void AssignParticipantToTaskCommandHandlerTests_Should_ReturnValidationEr
             var validator = new AssignParticipantToTaskCommandValidator(_mockTaskValidationService, _mockElectionWorkLocationTasksQueryRepository);
 
             _mockTaskValidationService
-                .ExecuteAsync(request.TaskTypeId, request.ElectionId, request.ParticipantId, default)
+                .ExecuteAsync(request.TaskAssignmentId, request.ElectionId, request.ParticipantId, default)
                 .Returns(Task.FromResult(new TaskValidationResult(new List<TaskValidationRule> { new TaskValidationRule(TaskValidationRule.Citizenship.Id) })));
 
             var result = validator.TestValidate(command);

diff --git a/Valghalla.Internal.Application/Modules/Tasks/Commands/AssignParticipantToTaskCommand.cs b/Valghalla.Internal.Application/Modules/Tasks/Commands/AssignParticipantToTaskCommand.cs
@@ -34,7 +34,7 @@ public AssignParticipantToTaskCommandValidator(ITaskValidationService taskValida
                .Must((command) => !electionWorkLocationTasksQueryRepository.CheckIfTaskHasConflictsAsync(command.ElectionId, command.TaskAssignmentId, command.ParticipantId, default).Result)
                .WithMessage("tasks.error.task_conflict");
 
-            RuleFor(x => taskValidationService.ExecuteAsync(x.TaskTypeId, x.ElectionId, x.ParticipantId, default).Result).Custom((result, context) =>
+            RuleFor(x => taskValidationService.ExecuteAsync(x.TaskAssignmentId, x.ElectionId, x.ParticipantId, default).Result).Custom((result, context) =>
             {
                 if (!result.IsAlive())
                 {

diff --git a/Valghalla.Internal.Application/Modules/Tasks/Responses/ParticipantTaskDetailsResponse.cs b/Valghalla.Internal.Application/Modules/Tasks/Responses/ParticipantTaskDetailsResponse.cs
@@ -9,8 +9,10 @@ public sealed record ParticipantTaskDetailsResponse
         public string? ParticipantEmail { get; set; }
         public string? ParticipantAddress { get; set; }
         public string? ParticipantSpecialDiets { get; set; }
+        public bool ParticipantDigitalPostStatus { get; set; }
         public string? AreaName { get; set; }
         public string? TeamName { get; set; }
+        public string? WorkLocation { get; set; }
         public string? TaskTypeName { get; set; }
         public DateTime? TaskDate { get; set; }
         public string? TaskStatus { get; set; }        

diff --git a/Valghalla.Internal.Infrastructure/Automapper/TaskProfile.cs b/Valghalla.Internal.Infrastructure/Automapper/TaskProfile.cs
@@ -56,6 +56,7 @@ public TaskProfile()
                 .ForMember(f => f.ParticipantName, opt => opt.MapFrom(src => src.Participant != null ? src.Participant.FirstName + " " + src.Participant.LastName : null))
                 .ForMember(f => f.ParticipantCpr, opt => opt.MapFrom(src => src.Participant!.Cpr))
                 .ForMember(f => f.ParticipantAge, opt => opt.MapFrom(src => src.Participant!.Age))
+                .ForMember(f => f.ParticipantDigitalPostStatus, opt => opt.MapFrom(src => !src.Participant!.ExemptDigitalPost))
                 .ForMember(f => f.ParticipantPhoneNumber, opt => opt.MapFrom(src => src.Participant!.MobileNumber))
                 .ForMember(f => f.ParticipantEmail, opt => opt.MapFrom(src => src.Participant!.Email))
                 .ForMember(f => f.ParticipantAddress, opt => opt.MapFrom(src => string.Join(", ", (new List<string>() { src.Participant!.CoAddress, src.Participant!.StreetAddress, src.Participant!.PostalCode, src.Participant!.City }).Where(s => !string.IsNullOrEmpty(s)))))
@@ -64,6 +65,7 @@ public TaskProfile()
                 .ForMember(f => f.TeamName, opt => opt.MapFrom(src => src.Team!.Name))
                 .ForMember(f => f.TaskTypeName, opt => opt.MapFrom(src => src.TaskType!.Title))
                 .ForMember(f => f.TaskDate, opt => opt.MapFrom(src => src.TaskDate))
+                .ForMember(f => f.WorkLocation, opt => opt.MapFrom(src => src.WorkLocation.Title))
                 .ForMember(f => f.TaskStartTime, opt => opt.MapFrom(src => src.TaskType!.StartTime))
                 .ForMember(f => f.TaskPayment, opt => opt.MapFrom(src => src.TaskType!.Payment))
                 .ForMember(f => f.TaskStatus, opt => opt.MapFrom(src => src.Accepted ? TaskStatus.Accepted.ToString() : (src.ParticipantId.HasValue ? TaskStatus.Unanswered.ToString() : TaskStatus.Available.ToString())))

diff --git a/Valghalla.Internal.Web/package.json b/Valghalla.Internal.Web/package.json
@@ -4,7 +4,7 @@
   "scripts": {
     "ng": "ng",
     "start": "node --max-http-header-size=100000 ./serve",
-    "build": "ng build",
+    "build": "ng build --output-hashing=all",
     "watch": "ng build --watch --configuration development",
     "test": "ng test",
     "lint": "ng lint",

diff --git a/Valghalla.Internal.Web/src/assets/i18n/da.json b/Valghalla.Internal.Web/src/assets/i18n/da.json
@@ -270,6 +270,8 @@
     "participant_list": {
       "page_title": "Deltagerlister",
       "labels": {
+        "participant_digital_post_status": "Digital Post status",
+        "work_location": "Arbejdssted",
         "show_preview": "Vis preview",
         "export_to_excel": "Eksportér som Excel-fil",
         "export_to_csv": "Eksportér som CSV-fil",

diff --git a/Valghalla.Internal.Web/src/assets/i18n/en.json b/Valghalla.Internal.Web/src/assets/i18n/en.json
@@ -270,6 +270,8 @@
     "participant_list": {
       "page_title": "Participant lists",
       "labels": {
+        "participant_digital_post_status": "Digital Post status",
+        "work_location": "Work location",
         "show_preview": "Show preview",
         "export_to_excel": "Export to Excel",
         "export_to_csv": "Export to CSV",
@@ -1162,4 +1164,4 @@
       "content": "404! Can't find the resource you are looking for"
     }
   }
-}
+}