Merge pull request 'Finishline' (#91) from finishline into main

Reviewed-on: #91

PostFundManagement.Api/Endpoints/Tools/EncodeIdEndpoint.cs

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

PostFundManagement.Application/Abstractions/Services/ICommunicationsService.cs

@@ -19,4 +19,18 @@ public interface ICommunicationsService
 
     [Log]
     Task<Result<Invite[]>> GetApplicantInvitesAsync(Guid applicantUserId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateNotificationAsync(CreateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateNotificationAsync(UpdateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Notification[]>> GetNotificationsAsync(string organisationIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Notification>> GetNotificationAsync(string notificationIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IGovernanceService.cs

@@ -46,4 +46,36 @@ public interface IGovernanceService
 
     [Log]
     Task<Result<Portfolio>> GetPortfolioAsync(string portfolioIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateTenantAsync(CreateTenantRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Tenant[]>> GetTenantsAsync(CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Tenant>> GetTenantAsync(string tenantIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateTenantAsync(UpdateTenantRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateTenantUserAsync(UpdateTenantUserRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateTenantOrganisationAsync(string organisationIdHash, string tenantIdHash, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateTenantOrganisationAsync(string tenantOrganisationIdHash, ActivityStatus status, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<TenantOrganisation[]>> GetTenantOrganisationsAsync(CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<TenantOrganisation>> GetTenantOrganisationAsync(string tenantOrganisationIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Abstractions/Services/IProjectService.cs

@@ -70,4 +70,88 @@ public interface IProjectService
 
     [Log]
     Task<Result<Project[]>> GetProgrammeProjectsAsync(string programmeIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateChangeRequestAsync(CreateChangeRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateChangeRequestAsync(UpdatehangeRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateComplianceItemAsync(CreateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateComplianceItemAsync(UpdateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateBeneficiaryAsync(CreateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateBeneficiaryItemAsync(UpdateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateIssueAsync(CreateIssueRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateIssueAsync(UpdateIssueRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateOutcomeAsync(CreateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateOutcomeAsync(UpdateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> CreateSiteVisitAsync(CreateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    [Audit]
+    Task<Result> UpdateSiteVisitAsync(UpdateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default);
+
+    [Log]
+    Task<Result<SiteVisit>> GetSiteVisitAsync(string SiteVisitIdHash, CancellationToken cancellationToken = default);
 }

PostFundManagement.Application/Extensions/Services.cs

@@ -8,7 +8,6 @@ using PostFundManagement.Application.Services.Governance;
 using PostFundManagement.Application.Services.Grants;
 using PostFundManagement.Application.Services.Projects;
 using PostFundManagement.Application.Services.Shared;
-using PostFundManagement.Application.Services.Tools;
 using PostFundManagement.Application.Services.Users;
 using PostFundManagement.Domain.Abstractions;
 
@@ -81,7 +80,6 @@ public static class Services
         services.AddLoggedAuditedCachedServiceScoped<IProjectService, ProjectService, ProjectCacheService>();
 
         services.AddLoggedCachedServiceScoped<IIdentityService, IdentityService, IdentityCacheService>();
-        services.AddLoggedCachedServiceScoped<IToolService, ToolService, ToolCacheService>();
 
         services.AddStackExchangeRedisCache(options =>
         {

PostFundManagement.Application/Services/Communications/CommunicationsCacheService.cs

@@ -11,6 +11,9 @@ namespace PostFundManagement.Application.Services.Communications;
 public sealed class CommunicationsCacheService(CommunicationsService service, IDistributedCache cache,
     IFeatureManager featureManager) : ServiceCacheBase, ICommunicationsService
 {
+    public async Task<Result> CreateNotificationAsync(CreateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateNotificationAsync(request, userId, cancellationToken);
+
     public async Task<Result<Invite>> GetApplicantInviteAsync(Guid applicantUserId, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Invite>>>)(async () =>
         {
@@ -80,7 +83,58 @@ public sealed class CommunicationsCacheService(CommunicationsService service, ID
 
             return Result.Ok(cached.FromJson<Invite[]>());
         }));
-    
+
+    public async Task<Result<Notification>> GetNotificationAsync(string notificationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Notification>>>)(async () =>
+        {
+            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+                return await service.GetNotificationAsync(notificationIdHash, cancellationToken);
+
+            var cacheKey = HashService.ToMd5Hash($"getnotification-{notificationIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetNotificationAsync(notificationIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return Result.Ok(result.Value);
+            }
+
+            return Result.Ok(cached.FromJson<Notification>());
+        }));
+
+    public async Task<Result<Notification[]>> GetNotificationsAsync(string organisationIdHash, CancellationToken cancellationToken = default) =>
+        await Result.Try((Func<Task<Result<Notification[]>>>)(async () =>
+        {
+            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
+                return await service.GetNotificationsAsync(organisationIdHash, cancellationToken);
+
+            var cacheKey = HashService.ToMd5Hash($"getnotifications-{organisationIdHash}").Value;
+
+            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
+
+            if (string.IsNullOrWhiteSpace(cached))
+            {
+                var result = await service.GetNotificationsAsync(organisationIdHash, cancellationToken);
+
+                if (result.IsFailed) return result;
+
+                await cache.SetStringAsync(cacheKey, result.Value.ToJson(), cacheOptions, cancellationToken);
+
+                return Result.Ok(result.Value);
+            }
+
+            return Result.Ok(cached.FromJson<Notification[]>());
+        }));
+
     public async Task<Result<Invite>> SendInviteAsync(InviteRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.SendInviteAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateNotificationAsync(UpdateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateNotificationAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Communications/CommunicationsService.cs

@@ -81,4 +81,24 @@ public sealed class CommunicationsService(IDbContextFactory<ApplicationDbContext
 
             return Result.Ok(invites.Select(i => i.Map()).ToArray());
         }));
+
+    public Task<Result> CreateNotificationAsync(CreateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateNotificationAsync(UpdateNotificationRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Notification[]>> GetNotificationsAsync(string organisationIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Notification>> GetNotificationAsync(string notificationIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
 }

PostFundManagement.Application/Services/Communications/Records.cs

@@ -3,6 +3,18 @@ using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Communications;
 
+public sealed record UpdateNotificationRequest([Required] long NotificationId,
+    [Required] NotificationStatus Status,
+    [Required] DateTime SentAt,
+    [Required][MaxLength(TextLength)] string Error);
+
+public sealed record CreateNotificationRequest([Required] long OrganisationId,
+    [Required] Guid Recipient,
+    [Required] NotificationPlatform Platform,
+    [Required][MaxLength(LabelLength)] string? Subject,
+    [Required][MaxLength(LabelLength)] string? Destination,
+    [Required][MaxLength(TextLength)] string Message);
+
 public sealed record InviteRequest([Required] long OrganisationId,
     [Required] long InvitedOrganisationId,
     [Required] long AwardId,

PostFundManagement.Application/Services/Governance/GovernanceCacheService.cs

@@ -17,6 +17,12 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
     public async Task<Result> CreatePortfolioAsync(CreatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreatePortfolioAsync(request, userId, cancellationToken);
 
+    public async Task<Result> CreateTenantAsync(CreateTenantRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateTenantAsync(request, userId, cancellationToken);
+
+    public async Task<Result> CreateTenantOrganisationAsync(string organisationIdHash, string tenantIdHash, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateTenantOrganisationAsync(organisationIdHash, tenantIdHash, userId, cancellationToken);
+
     public async Task<Result<Dashboard>> GetDashboardAsync(CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Dashboard>>>)(async () =>
         {
@@ -209,9 +215,38 @@ public sealed class GovernanceCacheService(GovernanceService service, IDistribut
             return Result.Ok(cached.FromJson<Programme[]>());
         }));
 
+    public Task<Result<Tenant>> GetTenantAsync(string tenantIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<TenantOrganisation>> GetTenantOrganisationAsync(string tenantOrganisationIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<TenantOrganisation[]>> GetTenantOrganisationsAsync(CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Tenant[]>> GetTenantsAsync(CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
     public async Task<Result<Organisation>> UpdateOrganisationAsync(UpdateOrganisationRequest request, CancellationToken cancellationToken = default) =>
         await service.UpdateOrganisationAsync(request, cancellationToken);
 
     public async Task<Result> UpdatePortfolioAsync(UpdatePortfolioRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdatePortfolioAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateTenantAsync(UpdateTenantRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateTenantAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateTenantOrganisationAsync(string tenantOrganisationIdHash, ActivityStatus status, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateTenantOrganisationAsync(tenantOrganisationIdHash, status, userId, cancellationToken);
+
+    public async Task<Result> UpdateTenantUserAsync(UpdateTenantUserRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateTenantUserAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Governance/GovernanceService.cs

@@ -252,4 +252,49 @@ public sealed class GovernanceService(IDbContextFactory<ApplicationDbContext> co
             return Result.FailIf(portfolio is null, NotFoundError.New)
                 .ToResult(portfolio!.Map());
         }));
+
+    public Task<Result> CreateTenantAsync(CreateTenantRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Tenant[]>> GetTenantsAsync(CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Tenant>> GetTenantAsync(string tenantIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateTenantAsync(UpdateTenantRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateTenantUserAsync(UpdateTenantUserRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateTenantOrganisationAsync(string organisationIdHash, string tenantIdHash, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateTenantOrganisationAsync(string tenantOrganisationIdHash, ActivityStatus status, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<TenantOrganisation[]>> GetTenantOrganisationsAsync(CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<TenantOrganisation>> GetTenantOrganisationAsync(string tenantOrganisationIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
 }

PostFundManagement.Application/Services/Governance/Records.cs

@@ -3,25 +3,35 @@ using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Governance;
 
+public sealed record UpdateTenantUserRequest([Required] Guid UserId, [Required] ActivityStatus Status);
+
+public sealed record CreateTenantUserRequest([Required] long TenantId, [Required] Guid UserId);
+
+public sealed record UpdateTenantRequest([Required] long TenantId,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required] ActivityStatus Status);
+
+public sealed record CreateTenantRequest([Required] long TenantId, [Required][MaxLength(LabelLength)] string Name);
+
 public sealed record UpdatePortfolioRequest([Required] long PortfolioId,
     [Required][MaxLength(LabelLength)] string Name,
-    [Required][MaxLength(TextLength)]  string Description, 
+    [Required][MaxLength(TextLength)] string Description,
     [Required] Guid OwnerId);
 
 public sealed record CreatePortfolioRequest([Required][MaxLength(LabelLength)] string Name,
-    [Required][MaxLength(TextLength)] string Description, 
+    [Required][MaxLength(TextLength)] string Description,
     [Required] long OrganisationId,
     [Required] Guid OwnerId);
 
 public sealed record UpdateOrganisationRequest([Required] long OrganisationId,
     [Required][MaxLength(LabelLength)] string Name,
     [Required][MaxLength(LabelLength)] string RegistrationNo,
-    [Required][EmailAddress][MaxLength(LabelLength)] string Email, 
+    [Required][EmailAddress][MaxLength(LabelLength)] string Email,
     [Required] OrganisationType Type);
 
-public sealed record CreateOrganisationRequest([Required][MaxLength(LabelLength)] string Name, 
+public sealed record CreateOrganisationRequest([Required][MaxLength(LabelLength)] string Name,
-    [Required][MaxLength(LabelLength)] string RegistrationNo, 
+    [Required][MaxLength(LabelLength)] string RegistrationNo,
-    [Required][EmailAddress][MaxLength(LabelLength)] string Email, 
+    [Required][EmailAddress][MaxLength(LabelLength)] string Email,
     [Required] OrganisationType Type = OrganisationType.PrivateLimitedCompany);
 
 public sealed record Dashboard([Required] decimal PortfolioValue,

PostFundManagement.Application/Services/Projects/ProjectCacheService.cs

@@ -14,12 +14,30 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
     public async Task<Result> CreateActivityAsync(CreateActivityRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateActivityAsync(request, userId, cancellationToken);
 
+    public async Task<Result> CreateBeneficiaryAsync(CreateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateBeneficiaryAsync(request, userId, cancellationToken);
+
+    public async Task<Result> CreateChangeRequestAsync(CreateChangeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateChangeRequestAsync(request, userId, cancellationToken);
+
+    public async Task<Result> CreateComplianceItemAsync(CreateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateComplianceItemAsync(request, userId, cancellationToken);
+
+    public async Task<Result> CreateIssueAsync(CreateIssueRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateIssueAsync(request, userId, cancellationToken);
+
+    public async Task<Result> CreateOutcomeAsync(CreateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateOutcomeAsync(request, userId, cancellationToken);
+
     public async Task<Result> CreateProgrammeAsync(CreateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProgrammeAsync(request, userId, cancellationToken);
 
     public async Task<Result> CreateProjectAsync(CreateProjectRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.CreateProjectAsync(request, userId, cancellationToken);
 
+    public async Task<Result> CreateSiteVisitAsync(CreateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.CreateSiteVisitAsync(request, userId, cancellationToken);
+
     public async Task<Result<Domain.Models.Activity[]>> GetActivitiesAsync(string projectIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Domain.Models.Activity[]>>>)(async () =>
         {
@@ -68,6 +86,46 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Domain.Models.Activity>());
         }));
 
+    public Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
     public async Task<Result<Milestone>> GetMilestoneAsync(string milestoneIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Milestone>>>)(async () =>
         {
@@ -116,6 +174,16 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Milestone[]>());
         }));
 
+    public Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
     public async Task<Result<Programme>> GetProgrammeAsync(string programmeIdHash, CancellationToken cancellationToken = default) =>
         await Result.Try((Func<Task<Result<Programme>>>)(async () =>
         {
@@ -308,9 +376,34 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
             return Result.Ok(cached.FromJson<Project[]>());
         }));
 
+    public Task<Result<SiteVisit>> GetSiteVisitAsync(string SiteVisitIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public async Task<Result> UpdateBeneficiaryItemAsync(UpdateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateBeneficiaryItemAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateChangeRequestAsync(UpdatehangeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateChangeRequestAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateComplianceItemAsync(UpdateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateComplianceItemAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateIssueAsync(UpdateIssueRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateIssueAsync(request, userId, cancellationToken);
+
     public async Task<Result> UpdateMilestoneAsync(UpdateMilestoneRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateMilestoneAsync(request, userId, cancellationToken);
 
+    public async Task<Result> UpdateOutcomeAsync(UpdateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateOutcomeAsync(request, userId, cancellationToken);
+
     public async Task<Result> UpdateProgrammeAsync(UpdateProgrammeRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProgrammeAsync(request, userId, cancellationToken);
 
@@ -319,4 +412,7 @@ public sealed class ProjectCacheService(ProjectService service, IDistributedCach
 
     public async Task<Result> UpdateProjectStatusAsync(UpdateProjectStatusRequest request, Guid userId, CancellationToken cancellationToken = default) =>
         await service.UpdateProjectStatusAsync(request, userId, cancellationToken);
+
+    public async Task<Result> UpdateSiteVisitAsync(UpdateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default) =>
+        await service.UpdateSiteVisitAsync(request, userId, cancellationToken);
 }

PostFundManagement.Application/Services/Projects/ProjectService.cs

@@ -382,4 +382,124 @@ public sealed class ProjectService(IDbContextFactory<ApplicationDbContext> conte
 
             return Result.Ok(projects.Select(i => i.Map()).ToArray());
         }));
+
+    public Task<Result> CreateChangeRequestAsync(CreateChangeRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateChangeRequestAsync(UpdatehangeRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ChangeRequest[]>> GetChangeRequestsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ChangeRequest>> GetChangeRequestAsync(string changeRequestIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateComplianceItemAsync(CreateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateComplianceItemAsync(UpdateComplianceItemRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ComplianceItem[]>> GetComplianceItemsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<ComplianceItem>> GetComplianceItemAsync(string complianceItemIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateBeneficiaryAsync(CreateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateBeneficiaryItemAsync(UpdateBeneficiaryRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Beneficiary[]>> GetBeneficiariesAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Beneficiary>> GetBeneficiaryAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateIssueAsync(CreateIssueRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateIssueAsync(UpdateIssueRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Issue[]>> GetIssuesAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Issue>> GetIssueAsync(string issueIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateOutcomeAsync(CreateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateOutcomeAsync(UpdateOutcomeRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Outcome[]>> GetOutcomesAsync(string beneficiaryIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<Outcome>> GetOutcomeAsync(string outcomeIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> CreateSiteVisitAsync(CreateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result> UpdateSiteVisitAsync(UpdateSiteVisitRequest request, Guid userId, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<SiteVisit[]>> GetSiteVisitsAsync(string projectIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
+
+    public Task<Result<SiteVisit>> GetSiteVisitAsync(string SiteVisitIdHash, CancellationToken cancellationToken = default)
+    {
+        throw new NotImplementedException();
+    }
 }

PostFundManagement.Application/Services/Projects/Records.cs

@@ -3,6 +3,75 @@ using static PostFundManagement.Domain.Extensions.Constants;
 
 namespace PostFundManagement.Application.Services.Projects;
 
+public sealed record UpdateSiteVisitRequest([Required] long SiteVisitId,
+    [Required][MaxLength(LabelLength)] string InspectorName,
+    [Required][MaxLength(TextLength)] string Findings,
+    [Required] ApprovalStatus Status,
+    [Required] DateTime VisitedAt);
+
+public sealed record CreateSiteVisitRequest([Required] long ProjectId,
+    [Required][MaxLength(LabelLength)] string InspectorName,
+    [Required][MaxLength(TextLength)] string Findings,
+    [Required] DateTime VisitedAt);
+
+public sealed record UpdateOutcomeRequest([Required] long OutcomeId,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(TextLength)] string Description);
+
+public sealed record CreateOutcomeRequest([Required] long BeneficiaryId,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(TextLength)] string Description);
+
+public sealed record UpdateIssueRequest([Required] long IssueId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Description,
+    [Required][MaxLength(TextLength)] string Resolution,
+    [Required] DateTime? ResolvedAt,
+    [Required] Priority Priority,
+    [Required] ActivityStatus Status,
+    [Required] Guid AssignedTo);
+
+public sealed record CreateIssueRequest([Required] long ProjectId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Description,
+    [Required] Priority Priority,
+    [Required] Guid AssignedTo);
+
+public sealed record UpdateBeneficiaryRequest([Required] long BeneficiaryId,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(LabelLength)] string Category,
+    [Required][MaxLength(LabelLength)] string Location,
+    [Required] int TargetCount,
+    [Required] int ReachedCount);
+
+public sealed record CreateBeneficiaryRequest([Required] long ProjectId,
+    [Required][MaxLength(LabelLength)] string Name,
+    [Required][MaxLength(LabelLength)] string Category,
+    [Required][MaxLength(LabelLength)] string Location,
+    [Required] int TargetCount,
+    [Required] int ReachedCount);
+
+public sealed record UpdateComplianceItemRequest([Required] long ComplianceItemId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Requirements,
+    [Required] ApprovalStatus Status);
+
+public sealed record CreateComplianceItemRequest([Required] long ProjectId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Requirements);
+
+public sealed record UpdatehangeRequest([Required] long ChangeRequestId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Justification,
+    [Required] decimal RevisedBudget,
+    [Required] ApprovalStatus Status);
+
+public sealed record CreateChangeRequest([Required] long ProjectId,
+    [Required][MaxLength(LabelLength)] string Title,
+    [Required][MaxLength(TextLength)] string Justification, 
+    [Required] decimal RevisedBudget, 
+    [Required] DateTime RevisionDate);
+
 public sealed record UpdateProgrammeRequest([Required] long ProgrammeId,
     [Required][MaxLength(LabelLength)] string Name, 
     [Required] Guid OwnerId, 

PostFundManagement.Application/Services/Tools/ToolCacheService.cs

@@ -1,34 +0,0 @@
-using PostFundManagement.Application.Abstractions;
-using PostFundManagement.Application.Abstractions.Services;
-using PostFundManagement.Application.Services.Shared;
-using static PostFundManagement.Domain.Extensions.Constants;
-
-namespace PostFundManagement.Application.Services.Tools;
-
-public sealed class ToolCacheService(ToolService service, IDistributedCache cache, 
-    IFeatureManager featureManager) : ServiceCacheBase, IToolService
-{
-    public async Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken) =>
-        await Result.Try((Func<Task<Result<string>>>)(async () =>
-        {
-            if (!await featureManager.IsEnabledAsync(ServiceCachingFeature))
-                return await service.EncodeLong(id, cancellationToken);
-
-            var cacheKey = HashService.ToMd5Hash($"encodelonghash-{id}").Value;
-
-            var cached = await cache.GetStringAsync(cacheKey, cancellationToken);
-
-            if(string.IsNullOrWhiteSpace(cached))
-            {
-                var result = (await service.EncodeLong(id).ConfigureAwait(false));
-
-                if (result.IsFailed) return result;
-
-                await cache.SetStringAsync(cacheKey, result.Value, cacheOptions, cancellationToken);
-
-                return result.Value;
-            }
-
-            return Result.Ok(cached);
-        }));
-}

PostFundManagement.Application/Services/Tools/ToolService.cs

@@ -1,10 +0,0 @@
-using PostFundManagement.Application.Abstractions.Services;
-using PostFundManagement.Application.Services.Shared;
-
-namespace PostFundManagement.Application.Services.Tools;
-
-public sealed class ToolService(HashService service) : IToolService
-{
-    public Task<Result<string>> EncodeLong(long id, CancellationToken cancellationToken = default) => 
-        Task.FromResult(service.HashEncodeLongId(id));
-}

PostFundManagement.Domain/Models/AuditChanges.cs

@@ -1,6 +0,0 @@
-namespace PostFundManagement.Domain.Models;
-
-public sealed class AuditChanges
-{
-    public string[]? Logs { get; set; }
-}