Added image name to compose file for console

Completed communication inte endpoints

Dockerfile

@@ -11,11 +11,6 @@ ENV DOTNET_CLI_TELEMETRY_OPTOUT=1 \
     NUGET_XMLDOC_MODE=skip
 WORKDIR /app_source
 
-COPY --from=node /usr/local/bin/node /usr/local/bin/node
-COPY --from=node /usr/local/lib/node_modules /usr/local/lib/node_modules
-RUN ln -s /usr/local/lib/node_modules/npm/bin/npm-cli.js /usr/local/bin/npm \
-    && npm install -g npm@latest
-
 COPY . .
 
 RUN dotnet restore "PostFundManagement.slnx"

PostFundManagement.Api/Endpoints/Communications/GetApplicantInviteEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Communications;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,9 +14,9 @@ public sealed class GetApplicantInviteEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/communications/invites/applicant/{userId:Guid}", async (Guid userId, CommunicationsService service,
+        builder.MapGet("api/communications/invites/applicant/{applicantUserId:Guid}", async (Guid applicantUserId, ICommunicationsService service,
             HttpContext context, CancellationToken cancellationToken = default) =>
-                await service.GetApplicantInviteAsync(userId, cancellationToken) switch
+                await service.GetApplicantInviteAsync(applicantUserId, cancellationToken) switch
                 {
                     {  IsSuccess: true, Value: var invite } => Results.Ok(invite),
                     var r when r.HasError<NotFoundError>() => Results.NotFound(),

PostFundManagement.Api/Endpoints/Communications/GetApplicantInvitesEndpoint.cs

@@ -0,0 +1,35 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Communications;
+
+[ApiVersionTarget(1)]
+public sealed class GetApplicantInvitesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/communications/invites/{applicantUserId:Guid}", async (Guid applicantUserId, ICommunicationsService service,
+            HttpContext context, CancellationToken cancellationToken = default) =>
+                await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken) switch
+                {
+                    {  IsSuccess: true, Value: var invite } => Results.Ok(invite),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Gets an applicant's invite list")
+            .WithName(typeof(GetApplicantInvitesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Invite[]>(StatusCodes.Status200OK)        
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Communications)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Communications/GetInvitesEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Communications;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -15,7 +15,7 @@ public sealed class GetInvitesEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/communications/invites/{page:int}/{pageSize:int}", async (CommunicationsService service,
+        builder.MapGet("api/communications/invites/{page:int}/{pageSize:int}", async (ICommunicationsService service,
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetInvitesAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Communications/SendInviteEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Communications;
 using PostFundManagement.Domain.Abstractions;
@@ -15,7 +16,7 @@ public sealed class SendInviteEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/communications/invite", async (InviteRequest request,
-            HttpContext context, CommunicationsService service, CancellationToken cancellationToken = default) =>
+            HttpContext context, ICommunicationsService service, CancellationToken cancellationToken = default) =>
                 await service.SendInviteAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var invite } => Results.Ok(invite),

PostFundManagement.Api/Endpoints/Evidence/CreateEvidenceEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public class CreateEvidenceEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPut("api/evidence/file", async (HttpRequest request, EvidenceService service, 
+        builder.MapPut("api/evidence/file", async (HttpRequest request, IEvidenceService service, 
             CancellationToken cancellationToken = default) =>
         {
             var userId = request.HttpContext.GetUserId();

PostFundManagement.Api/Endpoints/Evidence/CreateIndicatorEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateIndicatorEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/evidence/indicators", async (CreateIndicatorRequest request, HttpContext context,
-            EvidenceService service, CancellationToken cancellationToken = default) =>
+            IEvidenceService service, CancellationToken cancellationToken = default) =>
                 await service.CreateIndicatorAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Evidence/CreateMilestoneEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateMilestoneEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/evidence/milestones", async (CreateMilestoneRequest request, HttpContext context, 
-            EvidenceService service, CancellationToken cancellationToken = default) =>
+            IEvidenceService service, CancellationToken cancellationToken = default) =>
                 await service.CreateMilestoneAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public sealed class GetEvidenceEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/{evidenceId}", async (string evidenceId, EvidenceService service,
+        builder.MapGet("api/evidence/{evidenceId}", async (string evidenceId, IEvidenceService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetEvidenceAsync(evidenceId, cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceFilesEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public class GetEvidenceFilesEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/files/{page:int}/{pageSize:int}", async (EvidenceService service, 
+        builder.MapGet("api/evidence/files/{page:int}/{pageSize:int}", async (IEvidenceService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetEvidenceFilesAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public sealed class GetIndicatorEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/indicators/{indicatorId}", async (string indicatorId, EvidenceService service, 
+        builder.MapGet("api/evidence/indicators/{indicatorId}", async (string indicatorId, IEvidenceService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetIndicatorAsync(indicatorId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public sealed class GetIndicatorEndpoint : IEndpoint
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-        .WithTags(EndpointTags.Evidence);
+            .WithTags(EndpointTags.Evidence)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetIndicatorsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/indicators/{page:int}/{pageSize:int}", async (EvidenceService service, 
+        builder.MapGet("api/evidence/indicators/{page:int}/{pageSize:int}", async (IEvidenceService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetIndicatorsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetIndicatorsEndpoint : IEndpoint
             .Produces<Indicator[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Evidence);
+            .WithTags(EndpointTags.Evidence)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Evidence/GetMilestoneEvidenceEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public class GetMilestoneEvidenceEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/milestone/{milestoneId}", async (string milestoneId, EvidenceService service, 
+        builder.MapGet("api/evidence/milestone/{milestoneId}", async (string milestoneId, IEvidenceService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetMilestoneEvidencesAsync(milestoneId, cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Evidence/GetProjectEvidenceEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public class GetProjectEvidenceEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/evidence/milestone/{projectId}", async (string projectId, EvidenceService service, 
+        builder.MapGet("api/evidence/{projectId}", async (string projectId, IEvidenceService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetProjectEvidencesAsync(projectId, cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Evidence/RecordIndicatorAmountEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class RecordIndicatorAmountEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/evidence/indicators/{indicatorId}/actuals/{actualAmount:decimal}", async (string indicatorId, decimal actualAmount,
-            HttpContext context, EvidenceService service, CancellationToken cancellationToken = default) =>
+            HttpContext context, IEvidenceService service, CancellationToken cancellationToken = default) =>
                 await service.RecordIndicatorActualAmountAsync(indicatorId, actualAmount, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Evidence/UpdateEvidenceEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Evidence;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -13,19 +14,19 @@ public sealed class UpdateEvidenceEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPut("api/evidence", async (UpdateEvidenceRequest request, HttpContext context, EvidenceService service,
+        builder.MapPut("api/evidence", async (UpdateEvidenceRequest request, HttpContext context, IEvidenceService service,
             CancellationToken cancellationToken = default) =>
                 await service.UpdateEvidenceAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
                     var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Updates a specific evidence record metadata")
             .WithName(typeof(UpdateEvidenceEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
-            .Produces<Domain.Models.Evidence>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)

PostFundManagement.Api/Endpoints/Execution/ApproveDisbursementEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class ApproveDisbursementEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/execution/disbursements/{disbursementId}/approve", async (string disbursementId,
-            ExecutionService service, HttpContext context, CancellationToken cancellationToken = default) =>
+            IExecutionService service, HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.ApproveDisbursementAsync(disbursementId, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Execution/CreateDisbursementEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateDisbursementEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/execution/disbursements", async (CreateDisbursementRequest request, 
-            ExecutionService service, HttpContext context, CancellationToken cancellationToken = default) =>
+            IExecutionService service, HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.CreateDisbursementAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Execution/CreateRiskEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain.Abstractions;
@@ -13,7 +14,7 @@ public class CreateRiskEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPost("api/execution/risks", async (CreateRiskRequest request, ExecutionService service, 
+        builder.MapPost("api/execution/risks", async (CreateRiskRequest request, IExecutionService service, 
             HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.CreateRiskAsync(request, context.GetUserId(), cancellationToken) switch 
                 {

PostFundManagement.Api/Endpoints/Execution/GetDisbursementEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Execution;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public sealed class GetDisbursementEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/execution/disbursements/{disbursementId}", async (string disbursementId, ExecutionService service, 
+        builder.MapGet("api/execution/disbursements/{disbursementId}", async (string disbursementId, IExecutionService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetDisbursementAsync(disbursementIdHash: disbursementId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public sealed class GetDisbursementEndpoint : IEndpoint
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Execution);
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Execution/GetDisbursementsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetDisbursementsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/execution/disbursements", async (ExecutionService service, 
+        builder.MapGet("api/execution/disbursements", async (IExecutionService service, 
             int page = 1, int pageSize = 10, CancellationToken cancellationToken = default) =>
                 await service.GetDisbursementsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -28,6 +28,7 @@ public class GetDisbursementsEndpoint : IEndpoint
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Execution);
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Execution/GetRiskEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Execution;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public sealed class GetRiskEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/execution/risks/{riskId}", async (string riskId, ExecutionService service,
+        builder.MapGet("api/execution/risks/{riskId}", async (string riskId, IExecutionService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetRiskAsync(riskIdHash: riskId, cancellationToken) switch
                 {
@@ -30,6 +30,7 @@ public sealed class GetRiskEndpoint : IEndpoint
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Execution);
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Execution/GetRisksEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -13,7 +13,7 @@ public class GetRisksEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/execution/risks", async (ExecutionService service, 
+        builder.MapGet("api/execution/risks", async (IExecutionService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetRisksAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -26,6 +26,7 @@ public class GetRisksEndpoint : IEndpoint
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Execution);
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Execution/UpdateDisbursementEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -14,7 +15,7 @@ public sealed class UpdateDisbursementEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/execution/disbursements", async (UpdateDisbursementRequest request, HttpContext context, 
-            ExecutionService service, CancellationToken cancellationToken = default) =>
+            IExecutionService service, CancellationToken cancellationToken = default) =>
                 await service.UpdateDisbursementAsync(request, userId: context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Execution/UpdateRiskEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Execution;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -14,7 +15,7 @@ public sealed class UpdateRiskEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/execution/risks", async (UpdateRiskRequest request, 
-            ExecutionService service, CancellationToken cancellationToken = default) => 
+            IExecutionService service, CancellationToken cancellationToken = default) => 
                 await service.UpdateRiskAsync(request, cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Governance/CreateOrganisationEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public sealed class CreateOrganisationEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/governance/organisations", async (CreateOrganisationRequest request, HttpContext context, 
-            GovernanceService service, CancellationToken cancellationToken = default) =>
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
                 await service.CreateOrganisationAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Governance/CreatePortfolioEndpoint.cs

@@ -0,0 +1,38 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Governance;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class CreatePortfolioEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/governance/organisations/portfolio", async (CreatePortfolioRequest request, HttpContext context,
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.CreatePortfolioAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Create a new organization portfolio")
+            .WithName(typeof(CreatePortfolioEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/DashboardEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
@@ -12,7 +13,7 @@ public class DashboardEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/dashboard", async (GovernanceService service,
+        builder.MapGet("api/governance/dashboard", async (IGovernanceService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetDashboardAsync(cancellationToken) switch
                 {
@@ -25,6 +26,7 @@ public class DashboardEndpoint : IEndpoint
             .Produces<Dashboard>(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Governance);
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/GetInstrumentsEndpoint.cs

@@ -1,6 +1,7 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
 using PostFundManagement.Domain.Security;
@@ -13,19 +14,22 @@ public class GetInstrumentsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/instruments", async (GovernanceService service, 
+        builder.MapGet("api/governance/instruments/{programmeId}", async (string programmeId, IGovernanceService service, 
             CancellationToken cancellationToken = default) =>
-                await service.GetInstrumentsAsync(cancellationToken) switch
+                await service.GetInstrumentsAsync(programmeId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var instrumenrs } => Results.Ok(instrumenrs),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })
             .WithDescription("Get all funding instruments")
             .WithName(typeof(GetInstrumentsEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Instrument[]>(StatusCodes.Status200OK)
-            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Governance);
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/GetOrganisationEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -15,10 +15,10 @@ public class GetOrganisationEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/governance/organisations/{organisationId}", async (string organisationId,
-            GovernanceService service, CancellationToken cancellationToken = default) =>
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
                 await service.GetOrganisationAsync(organisationId, cancellationToken) switch
                 {
-                    { IsSuccess: true, Value: var organisation } => Results.Ok(organisationId),
+                    { IsSuccess: true, Value: var organisation } => Results.Ok(organisation),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r when r.HasError<NotFoundError>() => Results.NotFound(),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
@@ -31,6 +31,7 @@ public class GetOrganisationEndpoint : IEndpoint
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Governance);
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/GetOrganisationsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetOrganisationsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/organisations", async (GovernanceService service, 
+        builder.MapGet("api/governance/organisations", async (IGovernanceService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetOrganisationsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetOrganisationsEndpoint : IEndpoint
             .Produces<Organisation[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Governance);
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/GetPortfolioEndpoint.cs

@@ -0,0 +1,36 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetPortfolioEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/portfolios/{portfolioId}", async (string portfolioId, IGovernanceService service, 
+            CancellationToken cancellationToken = default) =>
+                await service.GetPortfolioAsync(portfolioIdHash: portfolioId, cancellationToken) switch
+                {
+                    {  IsSuccess: true, Value: var portfolio } => Results.Ok(portfolio),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get a specific portfolios")
+            .WithName(typeof(GetPortfolioEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Portfolio[]>(StatusCodes.Status200OK)
+            .Produces<Portfolio[]>(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetPortfolioProgrammesEndpoint.cs

@@ -0,0 +1,37 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetPortfolioProgrammesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/portfolios/{portfolioId}/programmes", async (string portfolioId, IGovernanceService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetPortfolioProgrammesAsync(portfolioId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var portfolios } => Results.Ok(portfolios),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get a programme's portfolios")
+            .WithName(typeof(GetPortfolioProgrammesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Programme[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetPortfoliosEndpoint.cs

@@ -1,6 +1,7 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
 using PostFundManagement.Domain.Security;
@@ -13,19 +14,22 @@ public class GetPortfoliosEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/portfolios", async (GovernanceService service, 
-            CancellationToken cancellationToken = default) =>
-                await service.GetPorfoliosAsync(cancellationToken) switch
+        builder.MapGet("api/governance/organisations/{organisationId}/portfolio", async (string organisationId,
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.GetPorfoliosAsync(organisationId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var portfolios } => Results.Ok(portfolios),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get all portfolios")
             .WithName(typeof(GetPortfoliosEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Portfolio[]>(StatusCodes.Status200OK)
-            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Governance);
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/GetProgrammesEndpoint.cs

@@ -1,6 +1,7 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
 using PostFundManagement.Domain.Security;
@@ -13,19 +14,22 @@ public class GetProgrammesEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/programmes", async (GovernanceService service, 
+        builder.MapGet("api/governance/programmes/{portfolioId}", async (string portfolioId, IGovernanceService service, 
             CancellationToken cancellationToken = default) =>
-                await service.GetProgrammesAsync(cancellationToken) switch
+                await service.GetProgrammesAsync(portfolioId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var programmes } => Results.Ok(programmes),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get all programmes")
             .WithName(typeof(GetProgrammesEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Programme[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Governance);
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Governance/UpdateOrganisationEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -14,7 +15,7 @@ public sealed class UpdateOrganisationEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/governance/organisations", async (UpdateOrganisationRequest request,
-            GovernanceService service, CancellationToken cancellationToken = default) => 
+            IGovernanceService service, CancellationToken cancellationToken = default) => 
                 await service.UpdateOrganisationAsync(request, cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Governance/UpdatePortfolioEndpoint.cs

@@ -0,0 +1,38 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Governance;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class UpdatePortfolioEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPut("api/governance/organisations/portfolio", async (UpdatePortfolioRequest request, HttpContext context, 
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.UpdatePortfolioAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    {  IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Update an existing organization portfolio")
+            .WithName(typeof(UpdatePortfolioEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Grants/CreateAwardEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateAwardEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/grants/awards", async (CreateAwardRequest request, HttpContext context, 
-            GrantsService service, CancellationToken cancellationToken = default) =>
+            IGrantsService service, CancellationToken cancellationToken = default) =>
                 await service.CreateAwardAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Grants/CreateBudgetEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateBudgetEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/grants/budgets", async (CreateBudgetRequest request, HttpContext context,
-            GrantsService service, CancellationToken cancellationToken = default) =>
+            IGrantsService service, CancellationToken cancellationToken = default) =>
                 await service.CreateBudgetAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     {  IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Grants/CreateContractEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateContractEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/grants/contracts", async (CreateContractRequest request, HttpContext context,
-            GrantsService service, CancellationToken cancellationToken = default) =>
+            IGrantsService service, CancellationToken cancellationToken = default) =>
                 await service.CreateContractAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Grants/ExecuteContractEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class ExecuteContractEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/grants/contracts/execute", async (ExecuteContractRequest request, HttpContext context,
-            GrantsService service, CancellationToken cancellationToken = default) =>
+            IGrantsService service, CancellationToken cancellationToken = default) =>
                 await service.ExecuteContractAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Grants/GetAwardEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetAwardEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/awards/{awardId}", async (string awardId, GrantsService service,
+        builder.MapGet("api/grants/awards/{awardId}", async (string awardId, IGrantsService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetAwardAsync(awardId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public class GetAwardEndpoint : IEndpoint
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-        .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/GetAwardsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetAwardsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/awards", async (GrantsService service, 
+        builder.MapGet("api/grants/awards", async (IGrantsService service, 
             int page = 1, int pageSize = 10, CancellationToken cancellationToken = default) =>
                 await service.GetAwardsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetAwardsEndpoint : IEndpoint
             .Produces<Award[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-        .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/GetBudgetEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetBudgetEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/budgets/{budgetId}", async (string budgetId, GrantsService service, 
+        builder.MapGet("api/grants/budgets/{budgetId}", async (string budgetId, IGrantsService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetBudgetAsync(budgetId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public class GetBudgetEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-        .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/GetBudgetsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetBudgetsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/budgets", async (GrantsService service, 
+        builder.MapGet("api/grants/budgets", async (IGrantsService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetBudgetsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetBudgetsEndpoint : IEndpoint
             .Produces<Budget[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-        .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/GetContractEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetContractEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/contracts/{contractId}", async (string contractId, GrantsService service, 
+        builder.MapGet("api/grants/contracts/{contractId}", async (string contractId, IGrantsService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetContractAsync(contractId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public class GetContractEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-        .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/GetContractsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetContractsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/grants/contracts", async (GrantsService service, 
+        builder.MapGet("api/grants/contracts", async (IGrantsService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetContractsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetContractsEndpoint : IEndpoint
             .Produces<Contract[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Grants);
+            .WithTags(EndpointTags.Grants)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/CreateActivityEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateActivityEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/projects/activities", async (CreateActivityRequest request, 
-            HttpContext context, ProjectService service, CancellationToken cancellationToken = default) =>
+            HttpContext context, IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.CreateActivityAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } result => Results.Ok(),

PostFundManagement.Api/Endpoints/Projects/CreateProgrammeEndpoint.cs

@@ -0,0 +1,37 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Projects;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateProgrammeEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/programme", async (CreateProgrammeRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.CreateProgrammeAsync(request, userId: context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Create programme")
+            .WithName(typeof(CreateProgrammeEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/CreateProjectEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class CreateProjectEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/projects", async (CreateProjectRequest request, HttpContext context,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.CreateProjectAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } result => Results.Ok(),

PostFundManagement.Api/Endpoints/Projects/GetActivitiesEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetActivitiesEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/projects/{projectId}/activities", async (string projectId,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.GetActivitiesAsync(projectId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var activities } => Results.Ok(activities),
@@ -28,6 +28,7 @@ public class GetActivitiesEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetActivityEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetActivityEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/projects/activities/{activityId}", async (string activityId,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.GetActivityAsync(activityId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var activity } => Results.Ok(activity),
@@ -30,6 +30,7 @@ public class GetActivityEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetMilestoneEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetMilestoneEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/projects/milestones/{milestoneId}", async (string milestoneId, ProjectService service, 
+        builder.MapGet("api/projects/milestones/{milestoneId}", async (string milestoneId, IProjectService service, 
             CancellationToken cancellationToken = default) =>
                 await service.GetMilestoneAsync(milestoneId, cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Projects/GetMilestonesEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,20 +14,20 @@ public class GetMilestonesEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/projects/milestones/{page:int}/{pageSize:int}", async (ProjectService service,
+        builder.MapGet("api/projects/milestones/{page:int}/{pageSize:int}", async (IProjectService service,
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetMilestonesAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var milestones } => Results.Ok(milestones),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
-            .RequireAuthorization()
             .WithDescription("Get a list of all milestones")
             .WithName(typeof(GetMilestonesEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Milestone[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetProgrammeEndpoint.cs

@@ -0,0 +1,36 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetProgrammeEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/programme/{programmeId}", async (string programmeId, IProjectService service, 
+            CancellationToken cancellationToken = default) =>
+                await service.GetProgrammeAsync(programmeId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var programme } => Results.Ok(programme),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get specific programme")
+            .WithName(typeof(GetProgrammeEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Programme>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)            
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetProgrammeProjectsEndpoint.cs

@@ -0,0 +1,37 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetProgrammeProjectsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/{programmeId}/programme", async (string programmeId,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.GetProgrammeProjectsAsync(programmeId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var projects } => Results.Ok(projects),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Get a list of all projects under a programme")
+            .WithName(typeof(GetProgrammeProjectsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Project[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetProgrammesEndpoint.cs

@@ -0,0 +1,35 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetProgrammesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/programme/{page:int}/{pageSize:int}", async (IProjectService service,
+            int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
+                await service.GetProgrammesAsync(Pagination.Create(page, pageSize), cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var programmes } => Results.Ok(programmes),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get a list of all programmes")
+            .WithName(typeof(GetProgrammesEndpoint).ToEndpointName("Projects"))
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Programme[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status404NotFound)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetProjectEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetProjectEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/projects/{projectId}", async (string projectId, ProjectService service,
+        builder.MapGet("api/projects/{projectId}", async (string projectId, IProjectService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetProjectAsync(projectId, cancellationToken) switch
                 {
@@ -31,6 +31,7 @@ public class GetProjectEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetProjectIndicatorsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetProjectIndicatorsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/projects/indicators/project/{projectId}", async (string projectId, ProjectService service,
+        builder.MapGet("api/projects/indicators/project/{projectId}", async (string projectId, IProjectService service,
             CancellationToken cancellationToken = default) =>
                 await service.GetProjectIndicatorsAsync(projectIdHash: projectId, cancellationToken) switch
                 {
@@ -30,6 +30,7 @@ public class GetProjectIndicatorsEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetProjectMilestonesEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -15,7 +15,7 @@ public class GetProjectMilestonesEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/projects/{projectId}/milestones", async (string projectId,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.GetProjectMilestonesAsync(projectId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var milestones } => Results.Ok(milestones),
@@ -30,6 +30,7 @@ public class GetProjectMilestonesEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetProjectRisksEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -15,7 +15,7 @@ public class GetProjectRisksEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/projects/{projectId}/risks", async (string projectId,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.GetProjectRisksAsync(projectId, cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var risks } => Results.Ok(risks),
@@ -30,6 +30,7 @@ public class GetProjectRisksEndpoint : IEndpoint
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/GetProjectsEndpoint.cs

@@ -1,5 +1,5 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public class GetProjectsEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/projects", async (ProjectService service, 
+        builder.MapGet("api/projects", async (IProjectService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetProjectsAsync(Pagination.Create(page, pageSize), cancellationToken) switch
                 {
@@ -27,6 +27,7 @@ public class GetProjectsEndpoint : IEndpoint
             .Produces<Project[]>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
-            .WithTags(EndpointTags.Projects);
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Projects/UpdateMilestoneEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
@@ -12,7 +13,7 @@ public sealed class UpdateMilestoneEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPut("api/projects/milestone", async (UpdateMilestoneRequest request, ProjectService service, 
+        builder.MapPut("api/projects/milestone", async (UpdateMilestoneRequest request, IProjectService service, 
             HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.UpdateMilestoneAsync(request, context.GetUserId(), cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Projects/UpdateProgrammeEndpoint.cs

@@ -0,0 +1,36 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Projects;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class UpdateProgrammeEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPut("api/projects/programme", async (UpdateProgrammeRequest request, HttpContext context, 
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.UpdateProgrammeAsync(request, userId: context.GetUserId(), cancellationToken) switch
+                {
+                    {  IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Update existing programme")
+            .WithName(typeof(UpdateProgrammeEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/UpdateProjectEndpoint.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -14,7 +15,7 @@ public sealed class UpdateProjectEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/projects", async (UpdateProjectRequest request, 
-            ProjectService service, HttpContext context, CancellationToken cancellationToken = default) =>
+            IProjectService service, HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.UpdateProjectAsync(request, userId: context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Projects/UpdateProjectStatusEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Domain.Abstractions;
@@ -14,7 +15,7 @@ public class UpdateProjectStatusEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/projects/status", async (UpdateProjectStatusRequest request, HttpContext context,
-            ProjectService service, CancellationToken cancellationToken = default) =>
+            IProjectService service, CancellationToken cancellationToken = default) =>
                 await service.UpdateProjectStatusAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/Endpoints/Tools/EncodeIdEndpoint.cs

@@ -0,0 +1,35 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Security;
+using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
+
+namespace PostFundManagement.Api.Endpoints.Tools;
+
+[ApiVersionTarget(1)]
+public sealed class EncodeIdEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/tools/hashid/{id64:long}", async (long id64, IToolService service, 
+            CancellationToken cancellationToken) =>
+                await service.EncodeLong(id64, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var hash } => Results.Ok(hash),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Hashes an int64 identifier")
+            .WithName(typeof(EncodeIdEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<string>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Tools)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Users/GetUserEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Users;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public sealed class GetUserEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/users/{userId:Guid}", async (Guid userId, UserService service,
+        builder.MapGet("api/users/{userId:Guid}", async (Guid userId, IUserService service,
             HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.GetUserAsync(userId, cancellationToken) switch
                 {
@@ -29,6 +29,7 @@ public sealed class GetUserEndpoint : IEndpoint
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Users);
+            .WithTags(EndpointTags.Users)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Users/GetUsersEndpoint.cs

@@ -1,3 +1,4 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Users;
 using PostFundManagement.Domain;
@@ -14,7 +15,7 @@ public class GetUsersEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPost("api/users/{page:int}/{pageSize:int}", async (UserFilterRequest request, UserService service, 
+        builder.MapPost("api/users/{page:int}/{pageSize:int}", async (UserFilterRequest request, IUserService service, 
             int page = 1, int pageSize = 100, CancellationToken cancellationToken = default) =>
                 await service.GetUsersAsync(Pagination.Create(page, pageSize), request, cancellationToken) switch
                 {
@@ -28,6 +29,7 @@ public class GetUsersEndpoint : IEndpoint
             .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Users);
+            .WithTags(EndpointTags.Users)
+            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Users/SyncUserEndpoint.cs

@@ -1,6 +1,6 @@
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Communications.Events;
-using PostFundManagement.Application.Services.Users;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -15,7 +15,7 @@ public class SyncUserEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPost("api/integration/sync", async (IJobOrchestrator jobOrchestrator,
-            HttpContext context, UserService service, CancellationToken cancellationToken = default) =>
+            HttpContext context, IUserService service, CancellationToken cancellationToken = default) =>
         {
             var result = await service.SyncUserAsync(context.GetUserId(), context.GetUserEmail(), cancellationToken);
 
@@ -35,6 +35,7 @@ public class SyncUserEndpoint : IEndpoint
         .Produces(StatusCodes.Status200OK)
         .Produces(StatusCodes.Status401Unauthorized)
         .Produces<Problems>(StatusCodes.Status500InternalServerError)
-        .WithTags(EndpointTags.Users);
+        .WithTags(EndpointTags.Users)
+        .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Users/UpdateUserStatusEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Users;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -15,7 +15,7 @@ public sealed class UpdateUserStatusEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapGet("api/users/{userId:Guid}/status/{status:int}", async (Guid userId, ActivityStatus status,
-            UserService service, CancellationToken cancellationToken = default) =>
+            IUserService service, CancellationToken cancellationToken = default) =>
                 await service.UpdateUserStatusAsync(userId, status, cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),

PostFundManagement.Api/PostFundManagement.Api.csproj

@@ -10,6 +10,14 @@
     <PackageLicenseFile>..\LICENSE</PackageLicenseFile>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <NoWarn>1701;1702;AV0029;AV0030;</NoWarn>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <NoWarn>1701;1702;AV0029;AV0030;</NoWarn>
+  </PropertyGroup>
+
   <!-- Security (IODC)-->
   <ItemGroup>
     <PackageReference Include="IdentityModel.AspNetCore" Version="4.3.0" />
@@ -43,7 +51,7 @@
   <ItemGroup>
     <PackageReference Include="AccessTokenClient.Extensions" Version="5.1.0" />
     <PackageReference Include="Asp.Versioning.Abstractions" Version="10.2.1" />
-    <PackageReference Include="Asp.Versioning.Http" Version="10.2.2" />
+    <PackageReference Include="Asp.Versioning.Http" Version="10.2.3" />
     <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="10.2.1" />
 
     <Using Include="Asp.Versioning" />
@@ -53,7 +61,7 @@
   <!-- API Documentation -->
   <ItemGroup>    
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.11" />    
-    <PackageReference Include="Scalar.AspNetCore" Version="2.17.1" />
+    <PackageReference Include="Scalar.AspNetCore" Version="2.17.2" />
 
     <Using Include="Scalar.AspNetCore" />
     <Using Include="Microsoft.OpenApi" />

PostFundManagement.Api/Program.cs

@@ -15,6 +15,9 @@ builder.Services.AddScoped<ActiveUserFilter>();
 
 builder.Services.AddEndpoints(Assembly.GetExecutingAssembly());
 builder.Services.AddApiServices(builder.Configuration);
+builder.Services.AddSharedServices();
+builder.Services.AddRegisterServicesWithCaching(builder.Configuration);
+builder.Services.AddEndpointAndServiceCaching(builder.Configuration);
 
 builder.Services.AddMediator();
 builder.Services.AddSecurityApiSdk(builder.Configuration);
@@ -27,7 +30,6 @@ builder.Services.AddQuartzScheduler(DefaultSchedulerName, builder.Configuration)
 builder.Services.AddEmailServices(builder.Configuration);
 builder.Services.AddHashServices(builder.Configuration);
 builder.Services.AddGarageS3(builder.Configuration);
-builder.Services.AddRegisterServices();
 
 builder.Services.AddHttpClient();
 builder.Services.AddDataProtectionDatabase(builder.Configuration);
@@ -38,6 +40,63 @@ builder.Services.AddHealthChecks()
     .AddCheck<PostgresHealthCheck>("PostgresDatabase")
     .AddCheck("Self", () => HealthCheckResult.Healthy());
 
+IEnumerable<string> identityScopes = ["openid", "profile", "roles", "email", "address"];
+
+builder.Services.AddValidation()
+    .AddEndpointValidation();
+
+builder.Services.AddOpenApi(options =>
+{
+    options.AddDocumentTransformer((document, context, cancellationToken) =>
+    {
+        document.Components ??= new OpenApiComponents();
+        document.Components?.SecuritySchemes!["OAuth2"] = new OpenApiSecurityScheme
+        {
+            Type = SecuritySchemeType.OAuth2,
+            Description = "Interactive OAuth2 flow for authentication and authorization",
+            Flows = new OpenApiOAuthFlows
+            {
+                AuthorizationCode = new OpenApiOAuthFlow
+                {
+                    AuthorizationUrl = new Uri($"{builder.Configuration["SecuritySettings:Authority"]}/connect/authorize"),
+                    TokenUrl = new Uri($"{builder.Configuration["SecuritySettings:Authority"]}/connect/token"),
+                    Scopes = new Dictionary<string, string>
+                    {
+                        { "openid", "OpenID Connect" },
+                        { "profile", "User Profile" },
+                        { "roles", "User Roles" },
+                        { "email", "User Email" },
+                        { "address", "User Address" },
+                        { builder.Configuration["SecuritySettings:Audience"]!, "PFM API Scope" }
+                    }
+                }
+            }
+        };
+
+        return Task.CompletedTask;
+    });
+
+    options.AddOperationTransformer((operation, context, cancellationToken) =>
+    {
+        operation.Security ??= [];
+
+        var schemeReference = new OpenApiSecuritySchemeReference("OAuth2");
+
+        operation.Security.Add(new OpenApiSecurityRequirement
+        {
+            [schemeReference] = [.. identityScopes, builder.Configuration["SecuritySettings:Audience"]!]
+        });
+
+        return Task.CompletedTask;
+    });
+});
+
+builder.Services.AddCors(options => options.AddPolicy("AllowFrontend", policy => 
+    policy.WithOrigins("https://localhost:3000", "https://localhost:8076", "https://console.ifri.khongisa.co.za")
+          .AllowAnyHeader()
+          .AllowAnyMethod()
+          .AllowCredentials()));
+
 var app = builder.Build();
 
 var schedulerFactory = app.Services.GetRequiredService<ISchedulerFactory>();
@@ -50,12 +109,13 @@ app.UseHsts();
 app.UseHttpsRedirection();
 
 app.UseRouting();
+app.UseCors("AllowFrontend");
+app.UseOutputCache();
 app.UseAuthentication();
 app.UseAuthorization();
 
 ApiVersionSet versionSet = app.NewApiVersionSet("v1")
     .HasApiVersion(new ApiVersion(1))
-    .HasApiVersion(new ApiVersion(2))
     .ReportApiVersions()
     .Build();
 
@@ -63,7 +123,7 @@ var versionGroups = new Dictionary<int, RouteGroupBuilder>
 {
     {
         1, app.MapGroup("v{version:apiVersion}").WithApiVersionSet(versionSet)
-            .RequireAuthorization().AddEndpointFilter<ActiveUserFilter>() 
+            .RequireAuthorization("ApiScope").AddEndpointFilter<ActiveUserFilter>()
     }
 };
 
@@ -86,14 +146,25 @@ var apiVersions = app.DescribeApiVersions()
     .ToList();
 
 foreach (var description in app.DescribeApiVersions().OrderByDescending(o => o.ApiVersion.MajorVersion))
+{
     app.MapScalarApiReference($"/openapi/{description.GroupName}", (options, context) =>
     {
         options.AddServer(new ScalarServer($"https://{context.Request.Host}"));
         options.WithOpenApiRoutePattern($"/openapi/{description.GroupName}.json");
         options.WithTheme(ScalarTheme.DeepSpace);
         options.Agent = new ScalarAgentOptions { Disabled = true };
-        options.Authentication = new ScalarAuthenticationOptions { PreferredSecuritySchemes = ["Bearer"] };
+        options.AddPreferredSecuritySchemes("OAuth2")
+               .AddOAuth2Flows("OAuth2", flow =>
+               {
+                   flow.AuthorizationCode = new AuthorizationCodeFlow
+                   {
+                       ClientId = builder.Configuration["SecuritySettings:ClientId"]!,
+                       Pkce = Pkce.Sha256,
+                       SelectedScopes = [.. identityScopes, builder.Configuration["SecuritySettings:Audience"]!]
+                   };
                });
+    });
+}
 
 var latestVersionGroup = apiVersions.FirstOrDefault()?.GroupName ?? "v1";
 

PostFundManagement.Api/appsettings.json

@@ -19,7 +19,7 @@
   },
   "Monitoring": {
     "Address": "http://aspire-dashboard-service.aspire.svc.cluster.local:18889",
-    "ServiceName": "MidrandBooks.DEV"
+    "ServiceName": "Pfm.DEV"
   },
   "SecuritySettings": {
     "Authority": "https://sts.security.khongisa.co.za",

PostFundManagement.Application/Abstractions/ServiceCacheBase.cs

@@ -0,0 +1,9 @@
+namespace PostFundManagement.Application.Abstractions;
+
+public abstract class ServiceCacheBase
+{
+    protected readonly DistributedCacheEntryOptions cacheOptions = new()
+    {
+        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(2)
+    };
+}

PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs

@@ -0,0 +1,16 @@
+using PostFundManagement.Application.Services.Communications;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface ICommunicationsService
+{
+    ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs

@@ -0,0 +1,30 @@
+using PostFundManagement.Application.Services.Evidence;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IEvidenceService
+{
+    ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken);
+
+    ValueTask<Result<Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IExecutionService.cs

@@ -0,0 +1,26 @@
+using PostFundManagement.Application.Services.Execution;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IExecutionService
+{
+    ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs

@@ -0,0 +1,32 @@
+using PostFundManagement.Application.Services.Governance;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IGovernanceService
+{
+    ValueTask<Result<Programme[]>> GetProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Portfolio[]>> GetPorfoliosAsync(string organisationIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Organisation[]>> GetOrganisationsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Organisation>> GetOrganisationAsync(string organisationIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Instrument[]>> GetInstrumentsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateOrganisationAsync(CreateOrganisationRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default);
+    
+    ValueTask<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
+    
+    ValueTask<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default);
+    
+    ValueTask<Result<Programme[]>> GetPortfolioProgrammesAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+    
+    ValueTask<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IGrantsService.cs

@@ -0,0 +1,28 @@
+using PostFundManagement.Application.Services.Grants;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IGrantsService
+{
+    ValueTask<Result<Contract[]>> GetContractsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Contract>> GetContractAsync(string contractIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Budget[]>> GetBudgetsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Budget>> GetBudgetAsync(string budgetIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Award[]>> GetAwardsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Award>> GetAwardAsync(string awardIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> ExecuteContractAsync(ExecuteContractRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateContractAsync(CreateContractRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateBudgetAsync(CreateBudgetRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateAwardAsync(CreateAwardRequest request, Guid userId, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IIdentityService.cs

@@ -0,0 +1,6 @@
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IIdentityService
+{
+    ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IProjectService.cs

@@ -0,0 +1,46 @@
+using PostFundManagement.Application.Services.Projects;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IProjectService
+{
+    ValueTask<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Project[]>> GetProjectsAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Project>> GetProjectAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Milestone[]>> GetProjectMilestonesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Indicator[]>> GetProjectIndicatorsAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Milestone[]>> GetMilestonesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateProjectAsync(UpdateProjectRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Domain.Models.Activity>> GetActivityAsync(string activityIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Risk[]>> GetProjectRisksAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default);
+    
+    ValueTask<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Programme[]>> GetProgrammesAsync(Pagination pagination, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+}

PostFundManagement.Application/Abstractions/Services/IToolService.cs

@@ -0,0 +1,6 @@
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IToolService
+{
+    ValueTask<Result<string>> EncodeLong(long id, CancellationToken cancellationToken);
+}

PostFundManagement.Application/Abstractions/Services/IUserService.cs

@@ -0,0 +1,16 @@
+using PostFundManagement.Application.Services.Users;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Abstractions.Services;
+
+public interface IUserService
+{
+    ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default);
+
+    ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default);
+
+    ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken);
+}

PostFundManagement.Application/Extensions/Api.cs

@@ -6,6 +6,23 @@ namespace PostFundManagement.Application.Extensions;
 
 public static class Api
 {
+    public static IServiceCollection AddEndpointValidation(this IServiceCollection services) => services.AddValidation();
+
+    public static IServiceCollection AddEndpointAndServiceCaching(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddStackExchangeRedisOutputCache(options =>
+        {
+            options.Configuration = configuration.GetConnectionString("Redis");
+            options.ConfigurationOptions?.ClientName = "PFM-API";
+            options.InstanceName = "PFM-API_";
+        });
+
+        services.AddOutputCache(options =>
+            options.AddBasePolicy(builder => builder.Expire(TimeSpan.FromMinutes(2))));
+
+        return services;
+    }
+
     public static void ConfigureCookieOidcSameSiteSupport(this IServiceCollection services) =>
         services.Configure<CookiePolicyOptions>(options =>
         {

PostFundManagement.Application/Extensions/General.cs

@@ -1,21 +1,12 @@
-using PostFundManagement.Application.Abstractions;
-using PostFundManagement.Domain.Abstractions;
-
-namespace PostFundManagement.Application.Extensions;
+namespace PostFundManagement.Application.Extensions;
 
 public static class General
 {
-    public static IServiceCollection AddRegisterServices(this IServiceCollection services)
-    {
-        var serviceType = typeof(IService);
+    public static string Clean(this string input) => Patterns.SpaceRegex().Replace(input, string.Empty);
 
-        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
-            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);
+    public static string ToJson<TValue>(this TValue obj) where TValue : class => JsonSerializer.Serialize(obj);
 
-        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);
-
-        return services;
-    }
+    public static TValue FromJson<TValue>(this string json) where TValue : class => JsonSerializer.Deserialize<TValue>(json)!;
 
     public static Guid GetUserId(this HttpContext context) => (Guid)context.Items[Domain.Extensions.Constants.UserIdItemKey]!;
 
@@ -23,26 +14,26 @@ public static class General
 
     public static (bool Decoded, Guid userId) GetUserId(this ClaimsPrincipal principal)
     {
-        var sidClaim = principal.FindFirst("sid")?.Value ?? principal.FindFirst(ClaimTypes.Sid)?.Value;
+        var subClaim = principal.FindFirst(JwtRegisteredClaimNames.Sub)?.Value ?? principal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
 
-        var decoded = Guid.TryParse(sidClaim, out var userId);
+        var decoded = Guid.TryParse(subClaim, out var userId);
 
         return (decoded, userId);
     }
 
-    public static (bool Decoded, Guid email) GetUserEmail(this ClaimsPrincipal principal)
+    public static (bool Decoded, string email) GetUserEmail(this ClaimsPrincipal principal)
     {
         var emailClaim = principal.FindFirst("email")?.Value ?? principal.FindFirst(ClaimTypes.Email)?.Value;
 
-        var decoded = Guid.TryParse(emailClaim, out var email);
+        var decoded = !string.IsNullOrWhiteSpace(emailClaim);
 
-        return (decoded, email);
+        return (decoded, emailClaim!);
     }
 
     public static Microsoft.AspNetCore.Mvc.ProblemDetails ToProblems(this IReadOnlyList<IError> errors) => new()
     {
         Detail = string.Join(',', errors.Select(e => e.Message)),
         Status = StatusCodes.Status400BadRequest,
-        Title = errors[0]?.Message,
+        Title = "Error",
     };
 }

PostFundManagement.Application/Extensions/Patterns.cs

@@ -0,0 +1,16 @@
+namespace PostFundManagement.Application.Extensions;
+
+public partial class Patterns
+{
+    [GeneratedRegex(@"\s+")]
+    public static partial Regex SpaceRegex();
+
+    [GeneratedRegex(@"\A\b[0-9a-fA-F]+\b\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    public static partial Regex HexHashRegex { get; }
+
+    [GeneratedRegex(@"\A[0-9a-fA-F]{32}\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    public static partial Regex Md5Regex { get; }
+
+    [GeneratedRegex(@"\A[0-9a-fA-F]{64}\Z", RegexOptions.None, matchTimeoutMilliseconds: 100)]
+    public static partial Regex Sha256Regex { get; }
+}

PostFundManagement.Application/Extensions/Security.cs

@@ -135,17 +135,25 @@ public static class Security
         services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
             .AddJwtBearer(options =>
             {
+                options.MapInboundClaims = false;
                 options.Authority = authOptions.Authority;
                 options.Audience = authOptions.Audience;
+
                 options.TokenValidationParameters = new TokenValidationParameters
                 {
                     ValidIssuer = authOptions.Authority,
                     ValidateAudience = true,
                     ValidateIssuer = true,
+                    ValidateLifetime = true,
                 };
             });
 
-        services.AddAuthorization();
+        services.AddAuthorizationBuilder()
+            .AddPolicy("ApiScope", policy =>
+            {
+                policy.RequireAuthenticatedUser();
+                policy.RequireClaim("scope", authOptions.Audience!);
+            });
 
         return services;
     }

PostFundManagement.Application/Extensions/Services.cs

@@ -0,0 +1,73 @@
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Communications;
+using PostFundManagement.Application.Services.Evidence;
+using PostFundManagement.Application.Services.Execution;
+using PostFundManagement.Application.Services.Governance;
+using PostFundManagement.Application.Services.Grants;
+using PostFundManagement.Application.Services.Projects;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Services.Tools;
+using PostFundManagement.Application.Services.Users;
+using PostFundManagement.Domain.Abstractions;
+
+namespace PostFundManagement.Application.Extensions;
+
+public static class Services
+{
+    public static IServiceCollection AddRegisterServicesWithCaching(this IServiceCollection services, IConfiguration configuration)
+    {
+        services.AddScoped<ICommunicationsService, CommunicationsService>();
+        services.Decorate<ICommunicationsService, CommunicationsCacheService>();
+
+        services.AddScoped<IEvidenceService, EvidenceService>();
+        services.Decorate<IEvidenceService, EvidenceCacheService>();
+
+        services.AddScoped<IUserService, UserService>();
+        services.Decorate<IUserService, UserCacheService>();
+
+        services.AddScoped<IIdentityService, IdentityService>();
+        services.Decorate<IIdentityService, IdentityCacheService>();
+
+        services.AddScoped<IExecutionService, ExecutionService>();
+        services.Decorate<IExecutionService, ExecutionCacheService>();
+        
+        services.AddScoped<IGovernanceService, GovernanceService>();
+        services.Decorate<IGovernanceService, GovernanceCacheService>();
+        
+        services.AddScoped<IGrantsService, GrantsService>();
+        services.Decorate<IGrantsService, GrantsCacheService>();
+        
+        services.AddScoped<IProjectService, ProjectService>();
+        services.Decorate<IProjectService, ProjectCacheService>();
+        
+        services.AddScoped<IToolService, ToolService>();
+        services.Decorate<IToolService, ToolCacheService>();
+
+        services.AddStackExchangeRedisCache(options =>
+        {
+            options.Configuration = configuration.GetConnectionString("Redis");
+            options.InstanceName = "PFM-API_";
+        });
+
+        services.AddHybridCache(options => options.DefaultEntryOptions = new HybridCacheEntryOptions
+        {
+            Expiration = TimeSpan.FromMinutes(2),
+            LocalCacheExpiration = TimeSpan.FromMinutes(30)
+        });
+
+        return services;
+    }
+
+    public static IServiceCollection AddSharedServices(this IServiceCollection services)
+    {
+        var serviceType = typeof(IService);
+
+        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
+            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);
+
+        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);
+
+        return services;
+    }
+}

PostFundManagement.Application/Filters/ActiveUserFilter.cs

@@ -1,10 +1,10 @@
-using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Abstractions.Services;
 using static PostFundManagement.Application.Extensions.General;
 using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Filters;
 
-public sealed class ActiveUserFilter(IdentityService identityService) : IEndpointFilter
+public sealed class ActiveUserFilter(IIdentityService identityService) : IEndpointFilter
 {
     public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
     {
@@ -22,6 +22,9 @@ public sealed class ActiveUserFilter(IdentityService identityService) : IEndpoin
         if (!emailDecoded)
             return Results.Json(new { message = "Invalid/missing user email in token." }, statusCode: StatusCodes.Status400BadRequest);
 
+        var path = context.HttpContext.Request.Path.Value;
+
+        if (!string.IsNullOrWhiteSpace(path) && !path!.EndsWith("integration/sync", StringComparison.InvariantCultureIgnoreCase))
             if ((await identityService.UserIsAuthorisedAsync(userId, context.HttpContext.RequestAborted)).IsFailed)
                 return (object?)Results.Json(new { message = "Account approval is pending or inactive." }, statusCode: StatusCodes.Status403Forbidden);
 

PostFundManagement.Application/PostFundManagement.Application.csproj

@@ -9,6 +9,14 @@
     <PackageLicenseFile>..\LICENSE</PackageLicenseFile>
   </PropertyGroup>
 
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+    <NoWarn>1701;1702;AV0029;AV0030;</NoWarn>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <NoWarn>1701;1702;AV0029;AV0030;</NoWarn>
+  </PropertyGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\PostFundManagement.Domain\PostFundManagement.Domain.csproj" />
     <ProjectReference Include="..\PostFundManagement.Infrastructure\PostFundManagement.Infrastructure.csproj" />
@@ -17,7 +25,8 @@
   <!-- API Documentation -->
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.11" />
-    <PackageReference Include="Scalar.AspNetCore" Version="2.17.1" />
+    <PackageReference Include="Microsoft.Extensions.Validation" Version="10.0.11" />
+    <PackageReference Include="Scalar.AspNetCore" Version="2.17.2" />
 
     <Using Include="Scalar.AspNetCore" />
     <Using Include="Microsoft.OpenApi" />
@@ -26,6 +35,11 @@
 
   <!-- Shared Usings -->
   <ItemGroup>
+    <Using Include="Humanizer" />
+    <Using Include="System.ComponentModel.DataAnnotations" />
+    <Using Include="Microsoft.Extensions.Caching.Distributed" />
+    <Using Include="Microsoft.Extensions.Caching.Hybrid" />
+    <Using Include="System.IdentityModel.Tokens.Jwt" />
     <Using Include="Asp.Versioning" />
     <Using Include="System.Security.Claims" />
     <Using Include="System.Diagnostics" />

PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs

@@ -0,0 +1,75 @@
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Services.Communications;
+
+public sealed class CommunicationsCacheService(CommunicationsService service, IDistributedCache cache) : ServiceCacheBase, ICommunicationsService
+{
+    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getapplicantinvite-{applicantUserId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetApplicantInviteAsync(applicantUserId, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+            }
+
+            return Result.Ok(cached!.FromJson<Invite>());
+        }));
+
+    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getapplicantinvites-{applicantUserId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if(string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Invite[]>());
+        }));
+
+    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getinvites-{pagination.Page}-{pagination.PageSize}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetInvitesAsync(pagination, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return Result.Ok(result.Value);
+            }
+
+            return Result.Ok(cached.FromJson<Invite[]>());
+        }));
+
+    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.SendInviteAsync(request, userId, cancellationToken);
+}

PostFundManagement.Application/Services/Communications/CommunicationsService.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Domain;
-using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Domain;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
@@ -7,7 +7,7 @@ using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Communications;
 
-public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
+public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : ICommunicationsService
 {
     public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
@@ -38,9 +38,8 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
                 CreatedAt = DateTime.UtcNow
             });
 
-            return await context.SaveChangesAsync(cancellationToken) > 0
-                ? Result.Ok(invite.Map())
-                : Result.Fail<Invite>(CreateError.New);
+            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New)
+                .ToResult(invite.Map());
         }));
 
     public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
@@ -57,15 +56,27 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
             return Result.Ok(invites.Select(i => i.Map()).ToArray());
         }));
 
-    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid userId, CancellationToken cancellationToken) =>
+    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken) =>
         await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
-            var invite = await context.Invites.AsNoTracking().FirstOrDefaultAsync(i => i.Recipient == userId, cancellationToken);
+            var invite = await context.Invites.AsNoTracking().FirstOrDefaultAsync(i => i.Recipient == applicantUserId, cancellationToken);
 
-            return invite is not null
-                ? Result.Ok(invite.Map())
-                : Result.Fail<Invite>(NotFoundError.New);
+            return Result.FailIf(invite is null, NotFoundError.New)
+                .ToResult(invite!.Map());
+        }));
+
+    public async ValueTask<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            var invites = await context.Invites.AsNoTracking()
+                .Where(i => i.Recipient == applicantUserId)
+                .OrderByDescending(o => o.CreatedAt)
+                .ToListAsync(cancellationToken);
+
+            return Result.Ok(invites.Select(i => i.Map()).ToArray());
         }));
 }

PostFundManagement.Application/Services/Communications/Records.cs

@@ -1,5 +1,12 @@
 using PostFundManagement.Domain;
+using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Communications;
 
-public record InviteRequest(long OrganisationId, long InvitedOrganisationId, long AwardId, long ContractId, Guid Recipient, string Message, NotificationPlatform Platform);
+public record InviteRequest([Required] long OrganisationId,
+    [Required] long InvitedOrganisationId,
+    [Required] long AwardId,
+    [Required] long ContractId,
+    [Required] Guid Recipient,
+    [Required][MaxLength(LabelLength)] string Message,
+    [Required] NotificationPlatform Platform);

PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs

@@ -0,0 +1,152 @@
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Services.Evidence;
+
+public sealed class EvidenceCacheService(EvidenceService service, IDistributedCache cache) : ServiceCacheBase, IEvidenceService
+{
+    public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
+        await service.CreateEvidenceAsync(userId, form, file, cancellationToken);
+
+    public async ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateIndicatorAsync(request, userId, cancellationToken);
+
+    public async ValueTask<Result> CreateMilestoneAsync(CreateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateMilestoneAsync(request, userId, cancellationToken);
+
+    public async ValueTask<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getevidence-{evidenceId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetEvidenceAsync(evidenceId, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Domain.Models.Evidence>());
+        }));
+
+    public async ValueTask<Result<Domain.Models.Evidence[]>> GetEvidenceFilesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getevidencefiles-{pagination.Page}-{pagination.PageSize}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetEvidenceFilesAsync(pagination, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
+        }));
+
+    public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Indicator>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getindicator-{indicatorId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetIndicatorAsync(indicatorId, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Indicator>());
+        }));
+
+    public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Indicator[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getindicators-{pagination.Page}-{pagination.PageSize}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetIndicatorsAsync(pagination, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Indicator[]>());
+        }));
+
+    public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getmilestoneevidences-{milestoneIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if(string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetMilestoneEvidencesAsync(milestoneIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
+        }));
+
+    public async ValueTask<Result<Domain.Models.Evidence[]>> GetProjectEvidencesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Domain.Models.Evidence[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getprojectevidences-{projectIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if(string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetProjectEvidencesAsync(projectIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Domain.Models.Evidence[]>());
+        }));
+
+    public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.RecordIndicatorActualAmountAsync(indicatorIdHash, amount, userId, cancellationToken);
+
+    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateEvidenceAsync(request, userId, cancellationToken);
+}

PostFundManagement.Application/Services/Evidence/EvidenceService.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -9,7 +10,7 @@ using PostFundManagement.Infrastructure.Database;
 namespace PostFundManagement.Application.Services.Evidence;
 
 public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
-    [FromKeyedServices(Constants.EvidenceBucketName)] IS3Service s3Service) : IService
+    [FromKeyedServices(Constants.EvidenceBucketName)] IS3Service s3Service) : IEvidenceService
 {
     public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>
@@ -46,7 +47,7 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
 
             context.Evidences.Add(evidence);
 
-            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
     public async ValueTask<Result> RecordIndicatorActualAmountAsync(string indicatorIdHash, decimal amount, Guid userId, CancellationToken cancellationToken = default) =>
@@ -65,7 +66,7 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                     .SetProperty(f => f.ActualAmount, amount)
                     .SetProperty(f => f.CreatedBy, userId), cancellationToken);
 
-            return Result.FailIf(changedTotal <= 0, UpdateError.New);
+            return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
     public async ValueTask<Result<Indicator[]>> GetIndicatorsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
@@ -101,6 +102,9 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
 
+            if (!await context.Users.AnyAsync(u => u.Id == userId, cancellationToken))
+                return Result.Fail(NotFoundError.New);
+
             if (!await context.Projects.AnyAsync(p => p.Id == request.ProjectId, cancellationToken))
                 return Result.Fail(NotFoundError.New);
 
@@ -115,7 +119,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 CreatedAt = DateTime.UtcNow
             });
 
-            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0,
+                CreateError.Create("No record could be created."));
         }));
 
     public async ValueTask<Result> CreateIndicatorAsync(CreateIndicatorRequest request, Guid userId, CancellationToken cancellationToken = default) =>
@@ -138,7 +143,7 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
                 CreatedAt = DateTime.UtcNow
             });
 
-            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
     public async ValueTask<Result<Indicator>> GetIndicatorAsync(string indicatorId, CancellationToken cancellationToken) =>
@@ -154,9 +159,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
 
             var indicator = await context.Indicators.AsNoTracking().FirstOrDefaultAsync(i => i.Id == decodeResult.Value, cancellationToken);
 
-            return indicator is not null
-                ? Result.Ok(indicator.Map())
-                : Result.Fail(NotFoundError.New);
+            return Result.FailIf(indicator is null, NotFoundError.New)
+                .ToResult(indicator!.Map());
         }));
 
     public async ValueTask<Result<Domain.Models.Evidence>> GetEvidenceAsync(string evidenceId, CancellationToken cancellationToken = default) =>
@@ -172,9 +176,8 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
 
             var evidence = await context.Evidences.AsNoTracking().FirstOrDefaultAsync(e => e.Id == decodeResult.Value, cancellationToken);
 
-            return evidence is not null
-                ? Result.Ok(evidence.Map())
-                : Result.Fail<Domain.Models.Evidence>(NotFoundError.New);
+            return Result.FailIf(evidence is null, NotFoundError.New)
+                .ToResult(evidence!.Map());
         }));
 
     public async ValueTask<Result<Domain.Models.Evidence[]>> GetMilestoneEvidencesAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
@@ -217,8 +220,22 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken)
+    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result>>)(async () =>
         {
-        throw new NotImplementedException();
-    }
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Evidences.AnyAsync(e => e.Id == request.EvidenceId, cancellationToken))
+                return Result.Fail(NotFoundError.New);
+
+            var changedTotal = await context.Evidences.Where(e => e.Id == request.EvidenceId)
+                .ExecuteUpdateAsync(f => f
+                    .SetProperty(f => f.Version, request.Version)
+                    .SetProperty(f => f.Type, request.EvidenceType)
+                    .SetProperty(f => f.Status, request.Status)
+                    .SetProperty(f => f.UpdatedBy, userId)
+                    .SetProperty(f => f.UpdatedAt, DateTime.UtcNow), cancellationToken);
+
+            return Result.OkIf(changedTotal > 0, UpdateError.New);
+        }));
 }

PostFundManagement.Application/Services/Evidence/Records.cs

@@ -1,11 +1,22 @@
 using PostFundManagement.Domain;
+using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Evidence;
 
-public record UpdateEvidenceRequest(long EvidenceId, int Version, EvidenceType EvidenceType, ApprovalStatus Status);
+public record UpdateEvidenceRequest([Required] long EvidenceId, 
+    [Required] int Version, 
+    [Required] EvidenceType EvidenceType, 
+    [Required] ApprovalStatus Status);
 
-public record RecordActualRequest(decimal ActualAmount);
+public record RecordActualRequest([Required] decimal ActualAmount);
 
-public record CreateMilestoneRequest(long ProjectId, DateTime DueAt, string Name, Priority Priority);
+public record CreateMilestoneRequest([Required] long ProjectId, 
+    [Required] DateTime DueAt, 
+    [Required][MaxLength(LabelLength)] string Name, 
+    [Required] Priority Priority);
 
-public record CreateIndicatorRequest(long ProjectId, string Name, UnitOfMeasure UnitOfMeasure, decimal BaselineAmount, decimal TargetAmount);
+public record CreateIndicatorRequest([Required] long ProjectId, 
+    [Required][MaxLength(LabelLength)] string Name, 
+    [Required] UnitOfMeasure UnitOfMeasure, 
+    [Required] decimal BaselineAmount, 
+    [Required] decimal TargetAmount);

PostFundManagement.Application/Services/Execution/ExecutionCacheService.cs

@@ -0,0 +1,110 @@
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Services.Execution;
+
+public sealed class ExecutionCacheService(ExecutionService service, IDistributedCache cache) : ServiceCacheBase, IExecutionService
+{
+    public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.ApproveDisbursementAsync(disbursementIdHash, userId, cancellationToken);
+
+    public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateDisbursementAsync(request, userId, cancellationToken);
+
+    public async ValueTask<Result> CreateRiskAsync(CreateRiskRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateRiskAsync(request, userId, cancellationToken);
+
+    public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Disbursement>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getdisbursement-{disbursementIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetDisbursementAsync(disbursementIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Disbursement>());
+        }));
+
+    public async ValueTask<Result<Disbursement[]>> GetDisbursementsAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Disbursement[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getdisbursements-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetDisbursementsAsync(pagination, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Disbursement[]>());
+        }));
+
+    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getrisk-{riskIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetRiskAsync(riskIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Risk>());
+        }));
+
+    public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getrisks-{pagination.Page}-{pagination.PageSize}-{pagination.Index}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetRisksAsync(pagination, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return result.Value;
+            }
+
+            return Result.Ok(cached.FromJson<Risk[]>());
+        }));
+
+    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateDisbursementAsync(request, userId, cancellationToken);
+
+    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
+        await service.UpdateRiskAsync(request, cancellationToken);
+}

PostFundManagement.Application/Services/Execution/ExecutionService.cs

@@ -1,6 +1,6 @@
-using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
-using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
@@ -8,7 +8,7 @@ using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Execution;
 
-public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IService
+public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService) : IExecutionService
 {
     public async ValueTask<Result<Risk[]>> GetRisksAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result<Risk[]>>>)(async () =>
@@ -57,7 +57,7 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 CreatedAt = DateTime.UtcNow
             });
 
-            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
     public async ValueTask<Result> CreateDisbursementAsync(CreateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
@@ -78,7 +78,7 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                 CreatedAt = DateTime.UtcNow
             });
 
-            return Result.FailIf(await context.SaveChangesAsync(cancellationToken) <= 0, CreateError.New);
+            return Result.OkIf(await context.SaveChangesAsync(cancellationToken) > 0, CreateError.New);
         }));
 
     public async ValueTask<Result> ApproveDisbursementAsync(string disbursementIdHash, Guid userId, CancellationToken cancellationToken = default) =>
@@ -98,7 +98,7 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                     .SetProperty(f => f.UpdatedBy, userId)
                     .SetProperty(f => f.UpdatedAt, DateTime.UtcNow), cancellationToken);
 
-            return Result.FailIf(changedTotal <= 0, UpdateError.New);
+            return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
     public async ValueTask<Result<Disbursement>> GetDisbursementAsync(string disbursementIdHash, CancellationToken cancellationToken) =>
@@ -115,12 +115,11 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             var disbursement = await context.Disbursements.AsNoTracking()
                 .FirstOrDefaultAsync(d => d.Id == decodeResult.Value, cancellationToken);
 
-            return disbursement is not null
-                ? Result.Ok(disbursement.Map())
-                : Result.Fail<Disbursement>(NotFoundError.New);
+            return Result.FailIf(disbursement is null, NotFoundError.New)
+                .ToResult(disbursement!.Map());
         }));
 
-    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken) =>
+    public async ValueTask<Result<Risk>> GetRiskAsync(string riskIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result<Risk>>>)(async () =>
         {
             var decodeResult = hashService.DecodeLongIdHash(riskIdHash);
@@ -134,12 +133,11 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
             var risk = await context.Risks.AsNoTracking()
                 .FirstOrDefaultAsync(r => r.Id == decodeResult.Value, cancellationToken);
 
-            return risk is not null
-                ? Result.Ok(risk.Map())
-                : Result.Fail<Risk>(NotFoundError.New);
+            return Result.FailIf(risk is null, NotFoundError.New)
+                .ToResult(risk!.Map());
         }));
 
-    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken) =>
+    public async ValueTask<Result> UpdateRiskAsync(UpdateRiskRequest request, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
@@ -152,10 +150,10 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                     .SetProperty(u => u.Likelihood, request.Likelihood)
                     .SetProperty(u => u.Impact, request.Impact), cancellationToken);
 
-            return Result.FailIf(changedTotal <= 0, UpdateError.New);
+            return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 
-    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken) =>
+    public async ValueTask<Result> UpdateDisbursementAsync(UpdateDisbursementRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>
         {
             await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
@@ -168,6 +166,6 @@ public sealed class ExecutionService(IDbContextFactory<ApplicationDbContext> con
                     .SetProperty(d => d.UpdatedAt, DateTime.UtcNow)
                     .SetProperty(d => d.UpdatedBy, userId), cancellationToken);
 
-            return Result.FailIf(changedTotal <= 0, UpdateError.New);
+            return Result.OkIf(changedTotal > 0, UpdateError.New);
         }));
 }

PostFundManagement.Application/Services/Execution/Records.cs

@@ -1,11 +1,20 @@
 using PostFundManagement.Domain;
+using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Execution;
 
-public record UpdateDisbursementRequest(long DisbursementId, long? MilestoneId, decimal Amount);
+public record UpdateDisbursementRequest([Required] long DisbursementId, long? MilestoneId, [Required] decimal Amount);
 
-public record UpdateRiskRequest(long RiskId, RiskLikelihood Likelihood, RiskImpact Impact, string Name, string Description);
+public record UpdateRiskRequest([Required] long RiskId,
+    [Required] RiskLikelihood Likelihood,
+    [Required] RiskImpact Impact,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(TextLength)] string Description);
 
-public record CreateDisbursementRequest(long ProjectId, long? MilestoneId, decimal Amount);
+public record CreateDisbursementRequest([Required] long ProjectId, long? MilestoneId, [Required] decimal Amount);
 
-public record CreateRiskRequest(long ProjectId, RiskLikelihood Likelihood, RiskImpact Impact, string Name, string Description);
+public record CreateRiskRequest([Required] long ProjectId,
+    [Required] RiskLikelihood Likelihood,
+    [Required] RiskImpact Impact,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(TextLength)] string Description);