Pathway Plan - Objectives and Tasks

src/Application/Common/Interfaces/IApplicationDbContext.cs

@@ -1,4 +1,4 @@
-using Cfo.Cats.Domain.Entities.Administration;
+using Cfo.Cats.Domain.Entities.Administration;
 using Cfo.Cats.Domain.Entities.Assessments;
 using Cfo.Cats.Domain.Entities.Documents;
 using Cfo.Cats.Domain.Entities.Participants;
@@ -25,6 +25,8 @@ public interface IApplicationDbContext
     DbSet<Document> Documents { get; }
 
     DbSet<Participant> Participants { get; }
+
+    DbSet<PathwayPlan> PathwayPlans { get; }
 
     DbSet<Risk> Risks { get; }
 

src/Application/Common/Interfaces/Identity/IUserService.cs

@@ -8,4 +8,5 @@ public interface IUserService
     event Action? OnChange;
     void Initialize();
     void Refresh();
+    string? GetDisplayName(string userId);
 }

src/Application/Common/Validators/RegularExpressionValidation.cs

@@ -5,7 +5,7 @@ public static class ValidationConstants
         public const string LettersSpacesUnderscores = @"^[A-Za-z_ ]+$";
         public const string LettersSpacesUnderscoresMessage = "{0} must contain only letters, spaces, and underscores.";
 
-        public const string LettersSpacesCommaApostorphe = @"^[A-Za-z ',’]+$";
+        public const string LettersSpacesCommaApostrophe = @"^[A-Za-z ',’]+$";
         public const string LettersSpacesCommaApostropheMessage = "{0} must contain only letters, spaces, comma and an apostrophe.";
 
         public const string AlphabetsDigitsSpaceSlashHyphenDot= @"^[a-zA-Z0-9\s\\\/\-.]+$";

src/Application/Features/Identity/DTOs/ApplicationUserDtoValidator.cs

@@ -57,7 +57,7 @@ public ApplicationUserDtoValidator(
 
         RuleFor(x => x.MemorablePlace)
             .MaximumLength(50).WithMessage(_localizer["Memorable place must be less than or equal to 50 characters"])
-            .Matches(ValidationConstants.LettersSpacesCommaApostorphe).WithMessage(_localizer[string.Format(ValidationConstants.LettersSpacesCommaApostropheMessage, "Memorable place")]);
+            .Matches(ValidationConstants.LettersSpacesCommaApostrophe).WithMessage(_localizer[string.Format(ValidationConstants.LettersSpacesCommaApostropheMessage, "Memorable place")]);
 
         RuleFor(x => x.MemorableDate)
             .NotEmpty().WithMessage(_localizer["Memorable date is required"])

src/Application/Features/Participants/Commands/AddConsent.cs

@@ -1,7 +1,6 @@
 using Cfo.Cats.Application.Common.Security;
 using Cfo.Cats.Application.SecurityConstants;
 using Cfo.Cats.Domain.Entities.Documents;
-using Cfo.Cats.Domain.Entities.Participants;
 
 namespace Cfo.Cats.Application.Features.Participants.Commands;
 

src/Application/Features/Participants/DTOs/ParticipantSummaryDto.cs

@@ -1,3 +1,4 @@
+using Cfo.Cats.Application.Features.PathwayPlans.DTOs;
 using Cfo.Cats.Application.Features.Bios.DTOs;
 using Cfo.Cats.Domain.Entities.Assessments;
 using Cfo.Cats.Domain.Entities.Participants;
@@ -44,6 +45,8 @@ public class ParticipantSummaryDto
     public RiskSummaryDto? LatestRisk { get; set; }
 
     public BioSummaryDto? BioSummary { get; set; }
+
+    public PathwayPlanSummaryDto? PathwayPlan { get; set; }
 
     private class Mapping : Profile
     {

src/Application/Features/Participants/Queries/GetParticipantSummary.cs

@@ -2,6 +2,7 @@
 using Cfo.Cats.Application.Common.Validators;
 using Cfo.Cats.Application.Features.Participants.Caching;
 using Cfo.Cats.Application.Features.Participants.DTOs;
+using Cfo.Cats.Application.Features.PathwayPlans.DTOs;
 using Cfo.Cats.Application.SecurityConstants;
 
 namespace Cfo.Cats.Application.Features.Participants.Queries;
@@ -41,20 +42,25 @@ public async Task<Result<ParticipantSummaryDto>> Handle(Query request, Cancellat
                 .ProjectTo<AssessmentSummaryDto>(mapper.ConfigurationProvider)
                 .ToArrayAsync(cancellationToken);
 
-            var risk = await unitOfWork.DbContext.Risks
+            summary.LatestRisk = await unitOfWork.DbContext.Risks
                 .OrderByDescending(x => x.Created)
+                .ProjectTo<RiskSummaryDto>(mapper.ConfigurationProvider)
                 .FirstOrDefaultAsync(x => x.ParticipantId == request.ParticipantId, cancellationToken);
 
-            summary.LatestRisk = mapper.Map<RiskSummaryDto>(risk);
-
+            summary.PathwayPlan = await unitOfWork.DbContext.PathwayPlans
+                .IgnoreAutoIncludes()
+                .Include(x => x.ReviewHistories)
+                .Where(x => x.ParticipantId == request.ParticipantId)
+                .ProjectTo<PathwayPlanSummaryDto>(mapper.ConfigurationProvider)
+                .FirstOrDefaultAsync(cancellationToken);
+
             var bio = await unitOfWork.DbContext.ParticipantBios
                 .OrderByDescending(x => x.Created)
                 .FirstOrDefaultAsync(x => x.ParticipantId == request.ParticipantId, cancellationToken);
 
             summary.BioSummary = mapper.Map<BioSummaryDto>(bio);
 
             return Result<ParticipantSummaryDto>.Success(summary);
-
         }
     }
 

src/Application/Features/PathwayPlans/Commands/AddObjective.cs

@@ -0,0 +1,61 @@
+using Cfo.Cats.Application.Common.Security;
+using Cfo.Cats.Application.Common.Validators;
+using Cfo.Cats.Application.SecurityConstants;
+using Cfo.Cats.Domain.Entities.Participants;
+
+namespace Cfo.Cats.Application.Features.PathwayPlans.Commands;
+
+public static class AddObjective
+{
+    [RequestAuthorize(Policy = SecurityPolicies.Enrol)]
+    public class Command : IRequest<Result>
+    {
+        [Description("Pathway Plan Id")]
+        public required Guid PathwayPlanId { get; set; }
+
+        public string? Title { get; set; }
+
+        public class Mapping : Profile
+        {
+            public Mapping()
+            {
+                CreateMap<Command, Objective>(MemberList.None)
+                    .ConstructUsing(dto => Objective.Create(dto.Title!, dto.PathwayPlanId));
+            }
+        }
+    }
+
+    public class Handler(IUnitOfWork unitOfWork, IMapper mapper) : IRequestHandler<Command, Result>
+    {
+        public async Task<Result> Handle(Command request, CancellationToken cancellationToken)
+        {
+            var objective = mapper.Map<Objective>(request);
+            var pathwayPlan = await unitOfWork.DbContext.PathwayPlans.FindAsync(request.PathwayPlanId);
+
+            if (pathwayPlan is null)
+            {
+                throw new NotFoundException("Cannot find pathway plan", request.PathwayPlanId);
+            }
+
+            pathwayPlan.AddObjective(objective);
+
+            return Result.Success();
+        }
+    }
+
+    public class Validator : AbstractValidator<Command>
+    {
+        public Validator()
+        {
+            RuleFor(x => x.PathwayPlanId)
+                .NotNull();
+
+            RuleFor(x => x.Title)
+                .NotEmpty()
+                .WithMessage("You must provide a title")
+                .Matches(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDot)
+                .WithMessage(string.Format(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDotMessage, "Title"));
+        }
+
+    }
+}

src/Application/Features/PathwayPlans/Commands/AddPathwayPlan.cs

@@ -0,0 +1,54 @@
+using Cfo.Cats.Application.Common.Security;
+using Cfo.Cats.Application.Common.Validators;
+using Cfo.Cats.Application.SecurityConstants;
+using Cfo.Cats.Domain.Entities.Participants;
+
+namespace Cfo.Cats.Application.Features.PathwayPlans.Commands;
+
+public static class AddPathwayPlan
+{
+    [RequestAuthorize(Policy = SecurityPolicies.Enrol)]
+    public class Command : IRequest<Result>
+    {
+        public required string ParticipantId { get; set; }
+
+        public class Mapping : Profile
+        {
+            public Mapping()
+            {
+                CreateMap<Command, PathwayPlan>(MemberList.None)
+                    .ConstructUsing(dto => PathwayPlan.Create(dto.ParticipantId));
+            }
+        }
+    }
+
+    public class Handler(IUnitOfWork unitOfWork, IMapper mapper) : IRequestHandler<Command, Result>
+    {
+        public async Task<Result> Handle(Command request, CancellationToken cancellationToken)
+        {
+            if (await unitOfWork.DbContext.PathwayPlans.AnyAsync(p => p.ParticipantId == request.ParticipantId))
+            {
+                return Result.Failure();
+            }
+
+            var pathwayPlan = mapper.Map<PathwayPlan>(request);
+
+            await unitOfWork.DbContext.PathwayPlans.AddAsync(pathwayPlan);
+
+            return Result.Success();
+        }
+    }
+
+    public class Validator : AbstractValidator<Command>
+    {
+        public Validator()
+        {
+            RuleFor(x => x.ParticipantId)
+                .MinimumLength(9)
+                .MaximumLength(9)
+                .Matches(ValidationConstants.AlphaNumeric)
+                .WithMessage(string.Format(ValidationConstants.AlphaNumericMessage, "Participant Id"));
+        }
+
+    }
+}

src/Application/Features/PathwayPlans/Commands/AddTask.cs

@@ -0,0 +1,85 @@
+using Cfo.Cats.Application.Common.Security;
+using Cfo.Cats.Application.Common.Validators;
+using Cfo.Cats.Application.SecurityConstants;
+using Cfo.Cats.Domain.Entities.Participants;
+
+namespace Cfo.Cats.Application.Features.PathwayPlans.Commands;
+
+public static class AddTask
+{
+    [RequestAuthorize(Policy = SecurityPolicies.Enrol)]
+    public class Command : IRequest<Result>
+    {
+        [Description("Pathway Plan Id")]
+        public required Guid PathwayPlanId { get; set; }
+
+        [Description("Objective Id")]
+        public required Guid ObjectiveId { get; set; }
+
+        public string? Title { get; set; }
+
+        public DateTime? Due { get; set; }
+
+        public class Mapping : Profile
+        {
+            public Mapping()
+            {
+                CreateMap<Command, ObjectiveTask>(MemberList.None)
+                    .ConstructUsing(dto => ObjectiveTask.Create(dto.Title!, dto.Due!.Value));
+            }
+        }
+    }
+
+    public class Handler(IUnitOfWork unitOfWork, IMapper mapper) : IRequestHandler<Command, Result>
+    {
+        public async Task<Result> Handle(Command request, CancellationToken cancellationToken)
+        {
+            var pathwayPlan = await unitOfWork.DbContext.PathwayPlans.FindAsync(request.PathwayPlanId)
+                ?? throw new NotFoundException("Cannot find pathway plan", request.PathwayPlanId);
+
+            var objective = pathwayPlan.Objectives.FirstOrDefault(o => o.Id == request.ObjectiveId)
+                ?? throw new NotFoundException("Cannot find objective", request.ObjectiveId);
+
+            var task = mapper.Map<ObjectiveTask>(request);
+
+            objective.AddTask(task);
+
+            return Result.Success();
+        }
+    }
+
+    public class Validator : AbstractValidator<Command>
+    {
+        public Validator()
+        {
+            var today = DateTime.UtcNow;
+
+            RuleFor(x => x.ObjectiveId)
+                .NotNull();
+
+            RuleFor(x => x.PathwayPlanId)
+                .NotNull();
+
+            RuleFor(x => x.Title)
+                .NotEmpty()
+                .WithMessage("You must provide a title")
+                .Matches(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDot)
+                .WithMessage(string.Format(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDotMessage, "Title"));
+
+            RuleFor(x => x.Due)
+                .Must(x => x.HasValue)
+                .WithMessage("You must provide a Due date");
+
+            When(x => x.Due.HasValue, () =>
+            {
+                RuleFor(x => x.Due)
+                    .GreaterThanOrEqualTo(new DateTime(today.Year, today.Month, 1))
+                    .WithMessage(ValidationConstants.DateMustBeInFuture)
+                    .Must(x => x!.Value.Day.Equals(1))
+                    .WithMessage("Due date must fall on the first day of the month");
+            });
+        }
+
+    }
+
+}

src/Application/Features/PathwayPlans/Commands/EditObjective.cs

@@ -0,0 +1,58 @@
+using Cfo.Cats.Application.Common.Security;
+using Cfo.Cats.Application.Common.Validators;
+using Cfo.Cats.Application.SecurityConstants;
+
+namespace Cfo.Cats.Application.Features.PathwayPlans.Commands;
+
+public static class EditObjective
+{
+    [RequestAuthorize(Policy = SecurityPolicies.Enrol)]
+    public class Command : IRequest<Result>
+    {
+        [Description("Objective Id")]
+        public required Guid ObjectiveId { get; set; }
+
+        [Description("Pathway Plan Id")]
+        public required Guid PathwayPlanId { get; set; }
+
+        [Description("Title")]
+        public required string Title { get; set; }
+    }
+
+    public class Handler(IUnitOfWork unitOfWork) : IRequestHandler<Command, Result>
+    {
+        public async Task<Result> Handle(Command request, CancellationToken cancellationToken)
+        {
+            var pathwayPlan = await unitOfWork.DbContext.PathwayPlans.FindAsync(request.PathwayPlanId)
+                ?? throw new NotFoundException("Cannot find pathway plan", request.PathwayPlanId);
+
+            var objective = pathwayPlan.Objectives.FirstOrDefault(o => o.Id == request.ObjectiveId)
+                ?? throw new NotFoundException("Cannot find objective", request.ObjectiveId);
+
+            objective.Rename(request.Title);
+
+            return Result.Success();
+        }
+    }
+
+    public class Validator : AbstractValidator<Command>
+    {
+        public Validator()
+        {
+            var today = DateTime.UtcNow;
+
+            RuleFor(x => x.ObjectiveId)
+                .NotNull();
+
+            RuleFor(x => x.PathwayPlanId)
+                .NotNull();
+
+            RuleFor(x => x.Title)
+                .NotEmpty()
+                .WithMessage("You must provide a title")
+                .Matches(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDot)
+                .WithMessage(string.Format(ValidationConstants.AlphabetsDigitsSpaceSlashHyphenDotMessage, "Title"));
+        }
+
+    }
+}