Merge pull request 'Fixed skoruba api address configs' (#139) from finishline into main

Reviewed-on: #139

.gitignore

@@ -12,6 +12,7 @@
 *.env
 *.env.json
 certificates/
+package-lock.json
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs

PostFundManagement.Api/Endpoints/Communications/GetApplicantInviteEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -14,12 +12,12 @@ public sealed class GetApplicantInviteEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/communications/invites/applicant/{applicantUserId:Guid}", async (Guid applicantUserId, ICommunicationsService service,
+        builder.MapGet("api/communications/invites/applicants/{applicantUserId:Guid}", async (Guid applicantUserId, ICommunicationsService service,
             HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.GetApplicantInviteAsync(applicantUserId, cancellationToken) switch
                 {
                     {  IsSuccess: true, Value: var invite } => Results.Ok(invite),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })
             .WithDescription("Gets an applicant's invite")
@@ -27,8 +25,8 @@ public sealed class GetApplicantInviteEndpoint : IEndpoint
             .WithName(typeof(GetApplicantInviteEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Invite>(StatusCodes.Status200OK)        
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Communications)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Communications/GetApplicantInvitesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class GetApplicantInvitesEndpoint : IEndpoint
                 await service.GetApplicantInvitesAsync(applicantUserId, cancellationToken) switch
                 {
                     {  IsSuccess: true, Value: var invite } => Results.Ok(invite),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })
             .WithDescription("Gets an applicant's invite list")
@@ -27,8 +25,8 @@ public sealed class GetApplicantInvitesEndpoint : IEndpoint
             .WithName(typeof(GetApplicantInvitesEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Invite[]>(StatusCodes.Status200OK)        
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Communications)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Communications/GetIApplicantDataEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Communications;
+
+[ApiVersionTarget(1)]
+public sealed class GetIApplicantDataEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/communications/applicants/{applicantUserId:Guid}/all", async (Guid applicantUserId, 
+            ICommunicationsService service, CancellationToken cancellationtToken = default ) =>
+                await service.GetApplicantDataAsync(applicantUserId, cancellationtToken) switch
+                {
+                    { IsSuccess: true, Value: var applicantData } => Results.Ok(applicantData),
+                    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("Gets an applicant's data")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetIApplicantDataEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Invite>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Communications)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Communications/GetInvitesEndpoint.cs

@@ -4,9 +4,6 @@ using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
-using PostFundManagement.Domain.Security;
-using static PostFundManagement.Application.Extensions.General;
-using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
 
 namespace PostFundManagement.Api.Endpoints.Communications;
 

PostFundManagement.Api/Endpoints/Communications/GetNotificationsEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Communications;
+
+[ApiVersionTarget(1)]
+public sealed class GetNotificationsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/communications/notifications/{organisationId}", async (string organisationId, 
+            ICommunicationsService service, CancellationToken cancellationToken = default) =>
+                await service.GetNotificationsAsync(organisationId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var notifications } => Results.Ok(notifications),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Retrieves the notification system report")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetNotificationsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Notification[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Notification[]>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Communications)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Communications/SendInviteEndpoint.cs

@@ -5,8 +5,6 @@ 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;
 
@@ -15,11 +13,12 @@ public sealed class SendInviteEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapPost("api/communications/invite", async (InviteRequest request,
+        builder.MapPost("api/communications/invites", async (InviteRequest request,
             HttpContext context, ICommunicationsService service, CancellationToken cancellationToken = default) =>
                 await service.SendInviteAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true, Value: var invite } => Results.Ok(invite),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -29,6 +28,7 @@ public sealed class SendInviteEndpoint : IEndpoint
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Invite>(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
             .WithTags(EndpointTags.Communications);

PostFundManagement.Api/Endpoints/Evidence/CreateEvidenceEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/CreateIndicatorEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Evidence;
 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.Evidence;
 
@@ -19,7 +17,7 @@ public class CreateIndicatorEndpoint : IEndpoint
                 await service.CreateIndicatorAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -28,8 +26,8 @@ public class CreateIndicatorEndpoint : IEndpoint
             .WithName(typeof(CreateIndicatorEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Evidence);

PostFundManagement.Api/Endpoints/Evidence/CreateMilestoneEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Evidence;
 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.Evidence;
 
@@ -19,7 +17,7 @@ public class CreateMilestoneEndpoint : IEndpoint
                 await service.CreateMilestoneAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -30,6 +28,7 @@ public class CreateMilestoneEndpoint : IEndpoint
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Evidence);
     }

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 
@@ -19,7 +17,7 @@ public sealed class GetEvidenceEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var evidence } => Results.Ok(evidence),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get a specific evidence record and assiciated file URLs")
@@ -27,9 +25,9 @@ public sealed class GetEvidenceEndpoint : IEndpoint
             .WithName(typeof(GetEvidenceEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Domain.Models.Evidence>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Evidence)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceFilesEndpoint.cs

@@ -3,8 +3,6 @@ using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
-using PostFundManagement.Domain.Security;
-using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
 
 namespace PostFundManagement.Api.Endpoints.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceUrlEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 
@@ -19,17 +17,17 @@ public sealed class GetEvidenceUrlEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var evidenceUrl } => Results.Ok(evidenceUrl),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Gets a secure download URL of the evidence file, URL expires (default: 15min)")
             .RequireAuthorization(Constants.MainScope)
             .WithName(typeof(GetEvidenceUrlEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
-            .Produces<string>(StatusCodes.Status200OK)
-            .Produces<string>(StatusCodes.Status404NotFound)
-            .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<string>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Grants)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorEndpoint.cs

@@ -4,8 +4,6 @@ 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.Evidence;
 
@@ -20,7 +18,7 @@ public sealed class GetIndicatorEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var indicator } => Results.Ok(indicator),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get a specific indicator.")
@@ -28,9 +26,9 @@ public sealed class GetIndicatorEndpoint : IEndpoint
             .WithName(typeof(GetIndicatorEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Indicator>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Evidence)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/GetMilestoneEvidenceEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/GetProjectEvidenceEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/RecordIndicatorAmountEndpoint.cs

@@ -3,8 +3,6 @@ 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.Evidence;
 

PostFundManagement.Api/Endpoints/Evidence/UpdateEvidenceEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Evidence;
 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.Evidence;
 
@@ -19,7 +17,7 @@ public sealed class UpdateEvidenceEndpoint : IEndpoint
                 await service.UpdateEvidenceAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -29,9 +27,9 @@ public sealed class UpdateEvidenceEndpoint : IEndpoint
             .WithName(typeof(UpdateEvidenceEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Evidence);

PostFundManagement.Api/Endpoints/Execution/ApproveDisbursementEndpoint.cs

@@ -3,8 +3,6 @@ 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.Execution;
 

PostFundManagement.Api/Endpoints/Execution/CreateDisbursementEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Execution;
 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.Execution;
 
@@ -19,7 +17,7 @@ public class CreateDisbursementEndpoint : IEndpoint
                 await service.CreateDisbursementAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })
@@ -28,9 +26,9 @@ public class CreateDisbursementEndpoint : IEndpoint
             .WithName(typeof(CreateDisbursementEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Execution);
     }

PostFundManagement.Api/Endpoints/Execution/CreateRiskEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Execution;
 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.Execution;
 
@@ -19,7 +17,7 @@ public class CreateRiskEndpoint : IEndpoint
                 await service.CreateRiskAsync(request, context.GetUserId(), cancellationToken) switch 
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -28,9 +26,9 @@ public class CreateRiskEndpoint : IEndpoint
             .WithName(typeof(CreateRiskEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Execution);
     }

PostFundManagement.Api/Endpoints/Execution/CreateRuleEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Execution;
+
+[ApiVersionTarget(1)]
+public sealed class CreateRuleEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/execution/rules", async (CreateRuleRequest request, HttpContext context,
+            IExecutionService service, CancellationToken cancellationToken = default) =>
+                await service.CreateRuleAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Add rule against a programme")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateRuleEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Execution);
+    }
+}

PostFundManagement.Api/Endpoints/Execution/GetDisbursementEndpoint.cs

@@ -4,8 +4,6 @@ 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.Execution;
 
@@ -20,7 +18,7 @@ public sealed class GetDisbursementEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var disbursement } => Results.Ok(disbursement),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get a specific disbursement")
@@ -28,9 +26,9 @@ public sealed class GetDisbursementEndpoint : IEndpoint
             .WithName(typeof(GetDisbursementEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Disbursement>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Execution)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Execution/GetDisbursementsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Execution;
 

PostFundManagement.Api/Endpoints/Execution/GetRiskEndpoint.cs

@@ -4,8 +4,6 @@ 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.Execution;
 
@@ -20,7 +18,7 @@ public sealed class GetRiskEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var risk  } => Results.Ok(risk),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get a specific risk")
@@ -28,8 +26,8 @@ public sealed class GetRiskEndpoint : IEndpoint
             .WithName(typeof(GetRiskEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Risk>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Execution)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Execution/GetRisksEndpoint.cs

@@ -3,8 +3,7 @@ using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
-using PostFundManagement.Domain.Security;
+using PostFundManagement.Domain.Models;
-using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
 
 namespace PostFundManagement.Api.Endpoints.Execution;
 
@@ -24,7 +23,7 @@ public class GetRisksEndpoint : IEndpoint
             .RequireAuthorization(Constants.MainScope)
             .WithName(typeof(GetRisksEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
-            .Produces(StatusCodes.Status200OK)
+            .Produces<Risk[]>(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Execution)

PostFundManagement.Api/Endpoints/Execution/GetRuleEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Execution;
+
+[ApiVersionTarget(1)]
+public sealed class GetRuleEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/execution/rules/{ruleId}", async (string ruleId, IExecutionService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetRuleAsync(ruleId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var rules } => Results.Ok(rules),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get a specific programme rule")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetRuleEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Rule>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Execution/GetRulesEndpoint.cs

@@ -0,0 +1,32 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Api.Endpoints.Execution;
+
+[ApiVersionTarget(1)]
+public sealed class GetRulesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/execution/programmes/rules", async (Pagination pagination, IExecutionService service, 
+            CancellationToken cancellationToken = default) =>
+                await service.GetRulesAsync(pagination, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var rules } => Results.Ok(rules),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Get a list of all programme rules")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetRulesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Rule[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Execution)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Execution/UpdateDisbursementEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Execution;
 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.Execution;
 

PostFundManagement.Api/Endpoints/Execution/UpdateRiskEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Execution;
 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.Execution;
 

PostFundManagement.Api/Endpoints/Execution/UpdateRuleEndpoint.cs

@@ -0,0 +1,33 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Execution;
+
+[ApiVersionTarget(1)]
+public sealed class UpdateRuleEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPut("api/execution/rules", async (UpdateRuleRequest request, HttpContext context,
+            IExecutionService service, CancellationToken cancellationToken = default) =>
+                await service.UpdateRuleAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Update the details of a specific programme rule (supplied version auto-increment)")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(UpdateRuleEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Execution);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/CreateInstrumentEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class CreateInstrumentEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/governance/instruments", async (CreateInstrumentRequest request, HttpContext context,
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.CreateInstrumentAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true} => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Creates a new programme funding instrument")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateInstrumentEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/CreateOrganisationEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,6 +17,7 @@ public sealed class CreateOrganisationEndpoint : IEndpoint
                 await service.CreateOrganisationAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })

PostFundManagement.Api/Endpoints/Governance/CreatePortfolioEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Governance/CreateTenantEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class CreateTenantEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/governance/tenants", async (CreateTenantRequest request, IGovernanceService service, HttpContext context,
+            CancellationToken cancellationToken = default) =>
+                await service.CreateTenantAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Create a new tenant")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateTenantEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)                        
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/DashboardEndpoint.cs

@@ -3,8 +3,6 @@ using PostFundManagement.Application.Extensions;
 using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Extensions;
-using PostFundManagement.Domain.Security;
-using Problems = Microsoft.AspNetCore.Mvc.ProblemDetails;
 
 namespace PostFundManagement.Api.Endpoints.Governance;
 

PostFundManagement.Api/Endpoints/Governance/GetAuditLogsEndpoint.cs

@@ -0,0 +1,33 @@
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Extensions;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetAuditLogsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/governance/auditlog", async (Pagination pagination, AuditService service, 
+            CancellationToken cancellationToken = default) =>
+                await service.GetAuditLogsAsync(pagination, cancellationToken) switch
+                {
+                    {  IsSuccess: true, Value: var logs } => Results.Ok(logs),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Retrieves audit logs based on pagination parameters")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetAuditLogsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<AuditLog[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetInstrumentsEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -18,7 +16,7 @@ public class GetInstrumentsEndpoint : IEndpoint
             CancellationToken cancellationToken = default) =>
                 await service.GetInstrumentsAsync(programmeId, cancellationToken) switch
                 {
-                    { IsSuccess: true, Value: var instrumenrs } => Results.Ok(instrumenrs),
+                    { IsSuccess: true, Value: var instruments } => Results.Ok(instruments),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })

PostFundManagement.Api/Endpoints/Governance/GetOrganisationEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -20,7 +18,7 @@ public class GetOrganisationEndpoint : IEndpoint
                 {
                     { 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 when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get organization profile by ID")
@@ -28,9 +26,9 @@ public class GetOrganisationEndpoint : IEndpoint
             .WithName(typeof(GetOrganisationEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Organisation>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces(StatusCodes.Status403Forbidden)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Governance)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Governance/GetOrganisationPortfoliosEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public class GetOrganisationPortfoliosEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/organisations/{organisationId}/portfolio", async (string organisationId,
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.GetOrganisationPorfoliosAsync(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 belonging to a specific organisation")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetOrganisationPortfoliosEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Portfolio[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetOrganisationsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Governance;
 

PostFundManagement.Api/Endpoints/Governance/GetPorfolioValueEndpoint.cs

@@ -0,0 +1,34 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetPorfolioValueEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/portfolios/{portfolioId}/value", async (string portfolioId, IGovernanceService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetPorfolioValueAsync(portfolioId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var amount } => Results.Ok(amount),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Calculates and returns a portfolio's total project's budget value")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetPorfolioValueEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<decimal>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetPortfolioEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class GetPortfolioEndpoint : IEndpoint
                 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 when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get a specific portfolios")
@@ -27,9 +25,9 @@ public sealed class GetPortfolioEndpoint : IEndpoint
             .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.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Governance)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Governance/GetPortfolioProgrammesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class GetPortfolioProgrammesEndpoint : IEndpoint
                 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<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -28,9 +26,9 @@ public sealed class GetPortfolioProgrammesEndpoint : IEndpoint
             .WithName(typeof(GetPortfolioProgrammesEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Programme[]>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Governance)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Governance/GetPortfoliosEndpoint.cs

@@ -1,25 +1,22 @@
-using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Abstractions.Services;
 using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain;
 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 class GetPortfoliosEndpoint : IEndpoint
+public sealed class GetPortfoliosEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/governance/organisations/{organisationId}/portfolio", async (string organisationId,
+        builder.MapPost("api/governance/organisations/portfolios", async (Pagination pagination, IGovernanceService service, 
-            IGovernanceService service, CancellationToken cancellationToken = default) =>
+            CancellationToken cancellationToken = default) =>
-                await service.GetPorfoliosAsync(organisationId, cancellationToken) switch
+                await service.GetPorfoliosAsync(pagination, 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")

PostFundManagement.Api/Endpoints/Governance/GetProgrammeValueEndpoint.cs

@@ -0,0 +1,34 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Errors;
+using PostFundManagement.Domain.Extensions;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetProgrammeValueEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/programmes/{programmeId}/value", async (string programmeId, IGovernanceService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetProgrammeValueAsync(programmeId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var amount } => Results.Ok(amount),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Calculates and returns a programme's total project budget value")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetProgrammeValueEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<decimal>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetProgrammesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Governance/GetTenantEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetTenantEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/tenants/{tenantId}", async (string tenantId, IGovernanceService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetTenantAsync(tenantId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var tenant } => Results.Ok(tenant),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets a single tenant")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetTenantsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Tenant>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetTenantOrganisationsEndpoint.cs

@@ -0,0 +1,33 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetTenantOrganisationsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/tenants/{tenantIdHash}/organisations", async (IGovernanceService service, string tenantIdHash,
+            CancellationToken cancellationToken = default) =>
+                await service.GetTenantOrganisationsAsync(tenantIdHash, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var tenantOrganisations } => Results.Ok(tenantOrganisations),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets organisations created and managed by one tenant")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetTenantOrganisationsEndpoint).ToEndpointName("Retrieval"))
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<TenantOrganisation[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/GetTenantsEndpoint.cs

@@ -0,0 +1,30 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
+using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Domain.Entities;
+using PostFundManagement.Domain.Extensions;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class GetTenantsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/governance/tenants", async (IGovernanceService service, 
+            CancellationToken cancellationToken = default) =>
+                await service.GetTenantsAsync(cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var tenants } => Results.Ok(tenants),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets system tenants")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetTenantsEndpoint).ToEndpointName("Retrieval"))
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Tenant[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance);
+    }
+}

PostFundManagement.Api/Endpoints/Governance/UpdateInstrumentEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Governance;
+
+[ApiVersionTarget(1)]
+public sealed class UpdateInstrumentEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPut("api/governance/instruments", async (UpdateInstrumentRequest request, HttpContext context,
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
+                await service.UpdateInstrumentAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Updates a programme funding instrument")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(UpdateInstrumentEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Governance/UpdateOrganisationEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -15,11 +13,13 @@ public sealed class UpdateOrganisationEndpoint : IEndpoint
     public void Map(IEndpointRouteBuilder builder)
     {
         builder.MapPut("api/governance/organisations", async (UpdateOrganisationRequest request,
-            IGovernanceService service, CancellationToken cancellationToken = default) => 
+            IGovernanceService service, HttpContext context, CancellationToken cancellationToken = default) =>
-                await service.UpdateOrganisationAsync(request, cancellationToken) switch
+                await service.UpdateOrganisationAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Update an existing organization profile")
@@ -27,10 +27,10 @@ public sealed class UpdateOrganisationEndpoint : IEndpoint
             .WithName(typeof(UpdateOrganisationEndpoint).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)
-            .Produces(StatusCodes.Status401Unauthorized)
             .WithTags(EndpointTags.Governance);
     }
 }

PostFundManagement.Api/Endpoints/Governance/UpdatePortfolioEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Governance/UpdateTenantEndpoint.cs

@@ -1,36 +1,34 @@
 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.Tools;
+namespace PostFundManagement.Api.Endpoints.Governance;
 
 [ApiVersionTarget(1)]
-public sealed class EncodeIdEndpoint : IEndpoint
+public sealed class UpdateTenantEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/tools/hashid/{id64:long}", async (long id64, IToolService service, 
+        builder.MapPut("api/governance/tenants", async (UpdateTenantRequest request, HttpContext context, 
-            CancellationToken cancellationToken) =>
+            IGovernanceService service, CancellationToken cancellationToken = default) =>
-                await service.EncodeLong(id64, cancellationToken) switch
+                await service.UpdateTenantAsync(request, context.GetUserId(), cancellationToken) switch
                 {
-                    { IsSuccess: true, Value: var hash } => Results.Ok(hash),
+                    { IsSuccess: true } => Results.Ok(),
                     var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
-            .WithDescription("Hashes an int64 identifier")
+            .WithDescription("Updates a specific tenant")
             .RequireAuthorization(Constants.MainScope)
-            .WithName(typeof(EncodeIdEndpoint).ToEndpointName())
+            .WithName(typeof(UpdateTenantEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
-            .Produces<string>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status403Forbidden)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
-            .WithTags(EndpointTags.Tools)
+            .WithTags(EndpointTags.Governance);
-            .CacheOutput();
     }
 }

PostFundManagement.Api/Endpoints/Grants/CreateAwardEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Grants;
 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.Grants;
 
@@ -19,7 +17,7 @@ public class CreateAwardEndpoint : IEndpoint
                 await service.CreateAwardAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
@@ -30,7 +28,7 @@ public class CreateAwardEndpoint : IEndpoint
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Grants);

PostFundManagement.Api/Endpoints/Grants/CreateBudgetEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Grants;
 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.Grants;
 
@@ -20,8 +18,8 @@ public class CreateBudgetEndpoint : IEndpoint
                 {
                     {  IsSuccess: true } => Results.Ok(),
                     var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
-                    var r when r.HasError<CreateError>() => Results.BadRequest(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Create a new budget line (M05)")
@@ -29,8 +27,8 @@ public class CreateBudgetEndpoint : IEndpoint
             .WithName(typeof(CreateBudgetEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)

PostFundManagement.Api/Endpoints/Grants/CreateContractEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Grants;
 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.Grants;
 
@@ -19,7 +17,7 @@ public class CreateContractEndpoint : IEndpoint
                 await service.CreateContractAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -29,6 +27,7 @@ public class CreateContractEndpoint : IEndpoint
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)
             .WithTags(EndpointTags.Grants);

PostFundManagement.Api/Endpoints/Grants/ExecuteContractEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Grants;
 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.Grants;
 

PostFundManagement.Api/Endpoints/Grants/GetAwardEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 
@@ -20,7 +18,7 @@ public class GetAwardEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var award } => Results.Ok(award),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get award by ID")
@@ -30,7 +28,7 @@ public class GetAwardEndpoint : IEndpoint
             .Produces<Award>(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Grants)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Grants/GetAwardsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 

PostFundManagement.Api/Endpoints/Grants/GetBudgetEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 
@@ -20,7 +18,7 @@ public class GetBudgetEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var budget } => Results.Ok(budget),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get budget by ID")
@@ -28,7 +26,7 @@ public class GetBudgetEndpoint : IEndpoint
             .WithName(typeof(GetBudgetEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Budget>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)

PostFundManagement.Api/Endpoints/Grants/GetBudgetsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 

PostFundManagement.Api/Endpoints/Grants/GetContractEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 
@@ -20,7 +18,7 @@ public class GetContractEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var contract } => Results.Ok(contract),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get contract by ID")
@@ -28,7 +26,7 @@ public class GetContractEndpoint : IEndpoint
             .WithName(typeof(GetContractEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Contract>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)

PostFundManagement.Api/Endpoints/Grants/GetContractUrlEndpoint.cs

@@ -3,8 +3,6 @@ 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.Grants;
 
@@ -19,7 +17,7 @@ public sealed class GetContractUrlEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var contractUrl} => Results.Ok(contractUrl),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Gets a secure download URL, has expiry period (default 15min)")
@@ -29,7 +27,7 @@ public sealed class GetContractUrlEndpoint : IEndpoint
             .Produces<string>(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Grants)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Grants/GetContractsEndpoint.cs

@@ -4,8 +4,6 @@ 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.Grants;
 

PostFundManagement.Api/Endpoints/Grants/UpdateBudgetEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Grants;
+
+[ApiVersionTarget(1)]
+public sealed class UpdateBudgetEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPut("api/grants/budgets", async (UpdateBudgetRequest request, HttpContext context,
+            IGrantsService service, CancellationToken cancellationToken = default) =>
+                await service.UpdateBudgetAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Updates a specific budget")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(UpdateBudgetEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)            
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Governance)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Grants/UpdateContractEndpoint.cs

@@ -4,8 +4,6 @@ using PostFundManagement.Application.Services.Grants;
 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.Grants;
 
@@ -19,7 +17,7 @@ public sealed class UpdateContractEndpoint : IEndpoint
                 await service.UpdateContractAsync(request, cancellationToken) switch
                 {
                     { IsSuccess: true } => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r when r.HasError<UpdateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
@@ -30,7 +28,7 @@ public sealed class UpdateContractEndpoint : IEndpoint
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status401Unauthorized)
-            .Produces(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Grants)

PostFundManagement.Api/Endpoints/Grants/UploadContractEndpoint.cs

@@ -3,8 +3,6 @@ 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.Grants;
 
@@ -40,7 +38,6 @@ public sealed class UploadContractEndpoint : IEndpoint
         .Produces(StatusCodes.Status200OK)
         .Produces(StatusCodes.Status403Forbidden)
         .Produces(StatusCodes.Status401Unauthorized)
-        .Produces(StatusCodes.Status404NotFound)
         .Produces<Problems>(StatusCodes.Status500InternalServerError)
         .WithTags(EndpointTags.Grants)
         .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/CreateActivityEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public class CreateActivityEndpoint : IEndpoint
                 await service.CreateActivityAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } result => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -28,6 +26,7 @@ public class CreateActivityEndpoint : IEndpoint
             .WithName(typeof(CreateActivityEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .Produces(StatusCodes.Status401Unauthorized)

PostFundManagement.Api/Endpoints/Projects/CreateBeneficiaryEndpoint.cs

@@ -0,0 +1,33 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateBeneficiaryEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/beneficiaries", async (CreateBeneficiaryRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.CreateBeneficiaryAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Add a new project beneficiary")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateBeneficiaryEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/CreateChangeRequestEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateChangeRequestEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/changerequests", async (CreateChangeRequest request, IProjectService service,
+            HttpContext context, CancellationToken cancellationToken = default) =>
+                await service.CreateChangeRequestAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems()),
+                })
+            .WithDescription("Create a new change request against an existing project")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateChangeRequestEndpoint).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/CreateComplianceItemEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateComplianceItemEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/complianceitems", async (CreateComplianceItemRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) => 
+                await service.CreateComplianceItemAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    {  IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Add a new beneficiary compliance item")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateComplianceItemEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/CreateIssueEndpoint.cs

@@ -0,0 +1,33 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateIssueEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/issues", async (CreateIssueRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.CreateIssueAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Add a new project issue")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateIssueEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/CreateOutcomeEndpoint.cs

@@ -0,0 +1,34 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateOutcomeEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/beneficiaris/outcomes", async (CreateOutcomeRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.CreateOutcomeAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Add a new beneficiary outcome")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateOutcomeEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Projects);
+    }
+}
+  

PostFundManagement.Api/Endpoints/Projects/CreateProgrammeEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class CreateProgrammeEndpoint : IEndpoint
                 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<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     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())
@@ -29,9 +27,9 @@ public sealed class CreateProgrammeEndpoint : IEndpoint
             .WithName(typeof(CreateProgrammeEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects);
     }

PostFundManagement.Api/Endpoints/Projects/CreateProjectEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public class CreateProjectEndpoint : IEndpoint
                 await service.CreateProjectAsync(request, context.GetUserId(), cancellationToken) switch
                 {
                     { IsSuccess: true } result => Results.Ok(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<ValidationError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
@@ -29,9 +27,9 @@ public class CreateProjectEndpoint : IEndpoint
             .WithName(typeof(CreateProjectEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status400BadRequest)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status401Unauthorized)
             .WithTags(EndpointTags.Projects);
     }

PostFundManagement.Api/Endpoints/Projects/CreateSiteVisitEndpoint.cs

@@ -0,0 +1,33 @@
+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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class CreateSiteVisitEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapPost("api/projects/sitevisits", async (CreateSiteVisitRequest request, HttpContext context,
+            IProjectService service, CancellationToken cancellationToken = default) =>
+                await service.CreateSiteVisitAsync(request, context.GetUserId(), cancellationToken) switch
+                {
+                    { IsSuccess: true } => Results.Ok(),
+                    var r when r.HasError<CreateError>() => Results.BadRequest(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Add a new project site visit")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(CreateSiteVisitEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces(StatusCodes.Status200OK)
+            .Produces<Problems>(StatusCodes.Status400BadRequest)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .WithTags(EndpointTags.Projects);
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetActivitiesEndpoint.cs

@@ -3,8 +3,6 @@ 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.Projects;
 

PostFundManagement.Api/Endpoints/Projects/GetActivityEndpoint.cs

@@ -3,8 +3,6 @@ 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.Projects;
 
@@ -19,7 +17,7 @@ public class GetActivityEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var activity } => Results.Ok(activity),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Gets a specific activity by it's id")
@@ -27,9 +25,9 @@ public class GetActivityEndpoint : IEndpoint
             .WithName(typeof(GetActivityEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Domain.Models.Activity>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/GetBeneficiariesEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetBeneficiariesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/{projectId}/beneficiaries", async (string projectId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetBeneficiariesAsync(projectId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var beneficiaries } => Results.Ok(beneficiaries),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project beneficiaries")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetBeneficiariesEndpoint).ToEndpointName("Retrieval"))
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Beneficiary[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetBeneficiaryEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetBeneficiaryEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/beneficiaries/{beneficiaryId}", async (string beneficiaryId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetBeneficiaryAsync(beneficiaryId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var beneficiary } => Results.Ok(beneficiary),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project beneficiaries")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetBeneficiariesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Beneficiary>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetChangeRequestEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetChangeRequestEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/changerequests/{changeRequestId}", async (string changeRequestId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetChangeRequestAsync(changeRequestId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var changeRequest } => Results.Ok(changeRequest),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets a specific project change request")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetChangeRequestEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<ChangeRequest>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetChangeRequestsEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetChangeRequestsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/{projectId}/changerequests", async (string projectId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetChangeRequestsAsync(projectId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var changeRequests } => Results.Ok(changeRequests),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project change requests")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetChangeRequestsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<ChangeRequest[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetComplianceItemEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetComplianceItemEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/complianceitems/{complianceItemId}", async (string complianceItemId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetComplianceItemAsync(complianceItemId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var complianceItem } => Results.Ok(complianceItem),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets a specific project compliance item")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetComplianceItemEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<ComplianceItem>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetComplianceItemsEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetComplianceItemsEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/{projectId}/complianceitems", async (string projectId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetComplianceItemsAsync(projectId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var complianceItems } => Results.Ok(complianceItems),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project compliance items")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetComplianceItemsEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<ComplianceItem[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetIssueEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetIssueEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/issues/{issueId}", async (string issueId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetIssueAsync(issueId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var issue } => Results.Ok(issue),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets a specific project issue")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetIssueEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Issue>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetIssuesEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetIssuesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/{projectId}/issues", async (string projectId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetIssuesAsync(projectId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var issues } => Results.Ok(issues),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project issues")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetIssuesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Issue[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetMilestoneEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -20,7 +18,7 @@ public class GetMilestoneEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var milestone } => Results.Ok(milestone),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Gets a specific milestone")
@@ -28,9 +26,9 @@ public class GetMilestoneEndpoint : IEndpoint
             .WithName(typeof(GetMilestoneEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Milestone>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/GetMilestonesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Projects/GetOutcomeEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetOutcomeEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/outcomes/{outcomeId}", async (string outcomeId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetOutcomeAsync(outcomeId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var outcome } => Results.Ok(outcome),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets a specific project outcome")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetOutcomeEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Outcome>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetOutcomesEndpoint.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;
+
+namespace PostFundManagement.Api.Endpoints.Projects;
+
+[ApiVersionTarget(1)]
+public sealed class GetOutcomesEndpoint : IEndpoint
+{
+    public void Map(IEndpointRouteBuilder builder)
+    {
+        builder.MapGet("api/projects/outcomes/{beneficiatyId}", async (string beneficiatyId, IProjectService service,
+            CancellationToken cancellationToken = default) =>
+                await service.GetOutcomesAsync(beneficiatyId, cancellationToken) switch
+                {
+                    { IsSuccess: true, Value: var outcomes } => Results.Ok(outcomes),
+                    var r when r.HasError<IdDecodeError>() => Results.Forbid(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
+                    var r => Results.InternalServerError(r.Errors.ToProblems())
+                })
+            .WithDescription("Gets project beneficiary outcomes")
+            .RequireAuthorization(Constants.MainScope)
+            .WithName(typeof(GetOutcomesEndpoint).ToEndpointName())
+            .MapToApiVersion(new ApiVersion(1))
+            .Produces<Outcome[]>(StatusCodes.Status200OK)
+            .Produces(StatusCodes.Status403Forbidden)
+            .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
+            .Produces<Problems>(StatusCodes.Status500InternalServerError)
+            .WithTags(EndpointTags.Projects)
+            .CacheOutput();
+    }
+}

PostFundManagement.Api/Endpoints/Projects/GetProgrammeEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class GetProgrammeEndpoint : IEndpoint
                 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<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
@@ -30,6 +28,7 @@ public sealed class GetProgrammeEndpoint : IEndpoint
             .Produces<Programme>(StatusCodes.Status200OK)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)            
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/GetProgrammeProjectsEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -19,7 +17,7 @@ public sealed class GetProgrammeProjectsEndpoint : IEndpoint
                 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<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
                     var r => Results.InternalServerError(r.Errors.ToProblems()),
                 })
@@ -28,9 +26,9 @@ public sealed class GetProgrammeProjectsEndpoint : IEndpoint
             .WithName(typeof(GetProgrammeProjectsEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Project[]>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/GetProgrammesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Projects/GetProjectEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 
@@ -20,7 +18,7 @@ public class GetProjectEndpoint : IEndpoint
                 {
                     { IsSuccess: true, Value: var project } => Results.Ok(project),
                     var r when r.HasError<IdDecodeError>() => Results.Forbid(),
-                    var r when r.HasError<NotFoundError>() => Results.NotFound(),
+                    var r when r.HasError<NotFoundError>() => Results.NotFound(r.Errors.ToProblems()),
                     var r => Results.InternalServerError(r.Errors.ToProblems())
                 })
             .WithDescription("Get project by ID")
@@ -28,9 +26,9 @@ public class GetProjectEndpoint : IEndpoint
             .WithName(typeof(GetProjectEndpoint).ToEndpointName())
             .MapToApiVersion(new ApiVersion(1))
             .Produces<Project[]>(StatusCodes.Status200OK)
-            .Produces(StatusCodes.Status404NotFound)
             .Produces(StatusCodes.Status403Forbidden)
             .Produces(StatusCodes.Status401Unauthorized)
+            .Produces<Problems>(StatusCodes.Status404NotFound)
             .Produces<Problems>(StatusCodes.Status500InternalServerError)
             .WithTags(EndpointTags.Projects)
             .CacheOutput();

PostFundManagement.Api/Endpoints/Projects/GetProjectIndicatorsEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Projects/GetProjectMilestonesEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Projects/GetProjectRisksEndpoint.cs

@@ -4,8 +4,6 @@ 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;
 

PostFundManagement.Api/Endpoints/Projects/GetProjectsEndpoint.cs

@@ -4,8 +4,6 @@ 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;