Merge pull request 'Added service level caching to IdentityService, Communication and Evidence' (#15) from endpoints into main

Reviewed-on: #15

PostFundManagement.Api/Endpoints/Communications/GetApplicantInviteEndpoint.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Application.Extensions;
-using PostFundManagement.Application.Services.Communications;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Extensions;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -14,7 +14,7 @@ public sealed class GetApplicantInviteEndpoint : IEndpoint
 {
     public void Map(IEndpointRouteBuilder builder)
     {
-        builder.MapGet("api/communications/invites/applicant/{userId:Guid}", async (Guid userId, CommunicationsService service,
+        builder.MapGet("api/communications/invites/applicant/{userId:Guid}", async (Guid userId, ICommunicationsService service,
             HttpContext context, CancellationToken cancellationToken = default) =>
                 await service.GetApplicantInviteAsync(userId, cancellationToken) switch
                 {

PostFundManagement.Api/Endpoints/Communications/GetInvitesEndpoint.cs

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

PostFundManagement.Api/Endpoints/Communications/SendInviteEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/CreateEvidenceEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/CreateIndicatorEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/CreateMilestoneEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetEvidenceFilesEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetIndicatorsEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetMilestoneEvidenceEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/GetProjectEvidenceEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/RecordIndicatorAmountEndpoint.cs

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

PostFundManagement.Api/Endpoints/Evidence/UpdateEvidenceEndpoint.cs

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

PostFundManagement.Api/Endpoints/Users/GetUserEndpoint.cs

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

PostFundManagement.Api/Endpoints/Users/GetUsersEndpoint.cs

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

PostFundManagement.Api/Endpoints/Users/SyncUserEndpoint.cs

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

PostFundManagement.Api/Endpoints/Users/UpdateUserStatusEndpoint.cs

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

PostFundManagement.Api/Program.cs

@@ -15,7 +15,8 @@ builder.Services.AddScoped<ActiveUserFilter>();
 
 builder.Services.AddEndpoints(Assembly.GetExecutingAssembly());
 builder.Services.AddApiServices(builder.Configuration);
-builder.Services.AddRegisterServices(builder.Configuration);
+builder.Services.AddSharedServices();
+builder.Services.AddRegisterServicesWithCaching(builder.Configuration);
 builder.Services.AddEndpointAndServiceCaching(builder.Configuration);
 
 builder.Services.AddMediator();

PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs

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

PostFundManagement.Application/Abstractions/Services/IEvidenceService.cs

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

PostFundManagement.Application/Abstractions/Services/IIdentityService.cs

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

PostFundManagement.Application/Abstractions/Services/IUserService.cs

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

PostFundManagement.Application/Extensions/General.cs

@@ -1,19 +1,28 @@
-using Microsoft.Extensions.Caching.Hybrid;
-using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Communications;
+using PostFundManagement.Application.Services.Evidence;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Services.Users;
 using PostFundManagement.Domain.Abstractions;
 
 namespace PostFundManagement.Application.Extensions;
 
 public static class General
 {
-    public static IServiceCollection AddRegisterServices(this IServiceCollection services, IConfiguration configuration)
+    public static IServiceCollection AddRegisterServicesWithCaching(this IServiceCollection services, IConfiguration configuration)
     {
-        var serviceType = typeof(IService);
+        services.AddScoped<ICommunicationsService, CommunicationsService>();
+        services.Decorate<ICommunicationsService, CommunicationsCacheService>();
 
-        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
-            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);
+        services.AddScoped<IEvidenceService, EvidenceService>();
+        services.Decorate<IEvidenceService, EvidenceCacheService>();
 
-        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);
+        services.AddScoped<IUserService, UserService>();
+        services.Decorate<IUserService, UserCacheService>();
+        
+        services.AddScoped<IIdentityService, IdentityService>();
+        services.Decorate<IIdentityService, IdentityCacheService>();
 
         services.AddStackExchangeRedisCache(options =>
             options.Configuration = configuration.GetConnectionString("Redis"));
@@ -27,6 +36,18 @@ public static class General
         return services;
     }
 
+    public static IServiceCollection AddSharedServices(this IServiceCollection services)
+    {
+        var serviceType = typeof(IService);
+
+        var sharedImplementations = typeof(IApplication).Assembly.GetTypes()
+            .Where(t => serviceType.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract);
+
+        foreach (var sharedImplementation in sharedImplementations) services.AddScoped(sharedImplementation);
+
+        return services;
+    }
+
     public static Guid GetUserId(this HttpContext context) => (Guid)context.Items[Domain.Extensions.Constants.UserIdItemKey]!;
 
     public static string GetUserEmail(this HttpContext context) => (string)context.Items[Domain.Extensions.Constants.EmailtemKey]!;

PostFundManagement.Application/Filters/ActiveUserFilter.cs

@@ -1,10 +1,10 @@
-using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Abstractions.Services;
 using static PostFundManagement.Application.Extensions.General;
 using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Filters;
 
-public sealed class ActiveUserFilter(IdentityService identityService) : IEndpointFilter
+public sealed class ActiveUserFilter(IIdentityService identityService) : IEndpointFilter
 {
     public async ValueTask<object?> InvokeAsync(EndpointFilterInvocationContext context, EndpointFilterDelegate next)
     {

PostFundManagement.Application/PostFundManagement.Application.csproj

@@ -26,6 +26,7 @@
 
   <!-- Shared Usings -->
   <ItemGroup>
+    <Using Include="Microsoft.Extensions.Caching.Hybrid" />
     <Using Include="System.IdentityModel.Tokens.Jwt" />
     <Using Include="Asp.Versioning" />
     <Using Include="System.Security.Claims" />

PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs

@@ -0,0 +1,22 @@
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Services.Communications;
+
+public sealed class CommunicationsCacheService(CommunicationsService service, HybridCache cache) : ICommunicationsService
+{
+    public async ValueTask<Result<Invite>> GetApplicantInviteAsync(Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>
+            await cache.GetOrCreateAsync(HashService.ToMd5Hash($"getapplicantinvite-{userId}").Value,
+                async cancel => await service.GetApplicantInviteAsync(userId, cancellationToken))));
+
+    public async ValueTask<Result<Invite[]>> GetInvitesAsync(Pagination pagination, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<Invite[]>>>)(async () =>
+            await cache.GetOrCreateAsync(HashService.ToMd5Hash($"getinvites-{pagination.Page}-{pagination.PageSize}").Value,
+                async cancel => await service.GetInvitesAsync(pagination, cancellationToken))));
+
+    public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.SendInviteAsync(request, userId, cancellationToken);
+}

PostFundManagement.Application/Services/Communications/CommunicationsService.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Domain;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
@@ -7,7 +8,7 @@ using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Communications;
 
-public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
+public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext> contextFactory) : ICommunicationsService
 {
     public async ValueTask<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result<Invite>>>)(async () =>

PostFundManagement.Application/Services/Evidence/EvidenceCacheService.cs

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

PostFundManagement.Application/Services/Evidence/EvidenceService.cs

@@ -1,4 +1,5 @@
-using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Shared;
 using PostFundManagement.Domain;
 using PostFundManagement.Domain.Abstractions;
 using PostFundManagement.Domain.Errors;
@@ -9,7 +10,7 @@ using PostFundManagement.Infrastructure.Database;
 namespace PostFundManagement.Application.Services.Evidence;
 
 public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> contextFactory, HashService hashService,
-    [FromKeyedServices(Constants.EvidenceBucketName)] IS3Service s3Service) : IService
+    [FromKeyedServices(Constants.EvidenceBucketName)] IS3Service s3Service) : IEvidenceService
 {
     public async ValueTask<Result> CreateEvidenceAsync(Guid userId, IFormCollection form, IFormFile file, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>
@@ -217,8 +218,22 @@ public sealed class EvidenceService(IDbContextFactory<ApplicationDbContext> cont
             return Result.Ok(evidences.Select(e => e.Map()).ToArray());
         }));
 
-    public async Task<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken)
-    {
-        throw new NotImplementedException();
-    }
+    public async ValueTask<Result> UpdateEvidenceAsync(UpdateEvidenceRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result>>)(async () =>
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+
+            if (!await context.Evidences.AnyAsync(e => e.Id == request.EvidenceId, cancellationToken))
+                return Result.Fail(NotFoundError.New);
+
+            var changedTotal = await context.Evidences.Where(e => e.Id == request.EvidenceId)
+                .ExecuteUpdateAsync(f => f
+                    .SetProperty(f => f.Version, request.Version)
+                    .SetProperty(f => f.Type, request.EvidenceType)
+                    .SetProperty(f => f.Status, request.Status)
+                    .SetProperty(f => f.UpdatedBy, userId)
+                    .SetProperty(f => f.UpdatedAt, DateTime.UtcNow), cancellationToken);
+
+            return Result.FailIf(changedTotal <= 0, UpdateError.New);
+        }));
 }

PostFundManagement.Application/Services/Shared/IdentityCacheService.cs

@@ -0,0 +1,31 @@
+using Microsoft.Extensions.Caching.Distributed;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Domain.Errors;
+
+namespace PostFundManagement.Application.Services.Shared;
+
+public sealed class IdentityCacheService(IdentityService service, IDistributedCache cache) : IIdentityService
+{
+    public async ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"userisauthorised-{userId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.UserIsAuthorisedAsync(userId, cancellationToken); ;
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, "true", cancellationToken);
+
+                return Result.Ok();
+            }
+
+            return cached.Equals("true", StringComparison.OrdinalIgnoreCase)
+                ? Result.Ok()
+                : Result.Fail(NotFoundError.New);
+        }));
+}

PostFundManagement.Application/Services/Shared/IdentityService.cs

@@ -1,11 +1,11 @@
-using PostFundManagement.Domain;
-using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Domain;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Shared;
 
-public sealed class IdentityService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
+public sealed class IdentityService(IDbContextFactory<ApplicationDbContext> contextFactory) : IIdentityService
 {
     public async ValueTask<Result> UserIsAuthorisedAsync(Guid userId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>

PostFundManagement.Application/Services/Users/UserCacheService.cs

@@ -0,0 +1,62 @@
+using Microsoft.Extensions.Caching.Distributed;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Application.Services.Shared;
+using PostFundManagement.Domain;
+using PostFundManagement.Domain.Models;
+
+namespace PostFundManagement.Application.Services.Users;
+
+public sealed class UserCacheService(UserService service, IDistributedCache cache) : IUserService
+{
+    public async ValueTask<Result<User>> GetUserAsync(Guid userId, CancellationToken cancellationToken) =>
+        await Result.Try((Func<ValueTask<Result<User>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getuser-{userId}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if(string.IsNullOrWhiteSpace(cached))
+            {
+                var userResult = await service.GetUserAsync(userId, cancellationToken);
+
+                if (userResult.IsFailed) return userResult;
+
+                await cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(userResult.Value));
+
+                return userResult;
+            }
+
+            var restored = JsonSerializer.Deserialize<User>(cached)!;
+
+            return Result.Ok(restored);
+        }));
+
+    public async ValueTask<Result<User[]>> GetUsersAsync(Pagination pagination, UserFilterRequest request, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<ValueTask<Result<User[]>>>)(async () =>
+        {
+            var cacheKey = HashService.ToMd5Hash($"getusers-{pagination.Page}-{pagination.PageSize}-{request.Email}-{request.Status}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var usersResult = await service.GetUsersAsync(pagination, request, cancellationToken);
+
+                if (usersResult.IsFailed) return usersResult;
+
+                await cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(usersResult.Value));
+
+                return usersResult;
+            }
+
+            var restored = JsonSerializer.Deserialize<User[]>(cached)!;
+
+            return Result.Ok(restored);
+        }));
+
+    public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
+        await service.SyncUserAsync(userId, email, cancellationToken);
+
+    public async ValueTask<Result> UpdateUserStatusAsync(Guid userId, ActivityStatus status, CancellationToken cancellationToken = default) =>
+        await service.UpdateUserStatusAsync(userId, status, cancellationToken);
+}

PostFundManagement.Application/Services/Users/UserService.cs

@@ -1,5 +1,5 @@
-using PostFundManagement.Domain;
-using PostFundManagement.Domain.Abstractions;
+using PostFundManagement.Application.Abstractions.Services;
+using PostFundManagement.Domain;
 using PostFundManagement.Domain.Errors;
 using PostFundManagement.Domain.Extensions;
 using PostFundManagement.Domain.Models;
@@ -7,7 +7,7 @@ using PostFundManagement.Infrastructure.Database;
 
 namespace PostFundManagement.Application.Services.Users;
 
-public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory) : IService
+public sealed class UserService(IDbContextFactory<ApplicationDbContext> contextFactory) : IUserService
 {
     public async ValueTask<Result> SyncUserAsync(Guid userId, string email, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<ValueTask<Result>>)(async () =>

PostFundManagement.Domain/PostFundManagement.Domain.csproj

@@ -15,6 +15,7 @@
     <PackageReference Include="Microsoft.AspNetCore.OutputCaching.StackExchangeRedis" Version="10.0.11" />
     <PackageReference Include="Microsoft.Extensions.Caching.Hybrid" Version="10.9.0" />
     <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="10.0.11" />
+    <PackageReference Include="Scrutor" Version="7.0.0" />
     
     <Using Include="Humanizer" />
   </ItemGroup>
@@ -72,7 +73,7 @@
 <!-- Quartz Scheduler-->
 <ItemGroup>    
   <PackageReference Include="Hashids.net" Version="1.7.0" />    
-  <PackageReference Include="Meziantou.Analyzer" Version="3.0.200">
+  <PackageReference Include="Meziantou.Analyzer" Version="3.0.203">
     <PrivateAssets>all</PrivateAssets>
     <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
   </PackageReference>